gomyck-tools 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

ctools/ai/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/5/22 15:56'

ctools/ai/env_config.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/5/16 16:42'
+
+import json
+import os
+from typing import Any
+
+from dotenv.main import DotEnv
+
+
+class Configuration:
+  """Manages configuration and environment variables for the MCP client."""
+
+  def __init__(self, dotenv_path: str=".env") -> None:
+    """Initialize configuration with environment variables."""
+    if not os.path.exists(dotenv_path): raise FileNotFoundError(f"Could not find .env file at {dotenv_path}")
+    self.env = DotEnv(dotenv_path=dotenv_path)
+
+  def get_env(self, key: str) -> str:
+    value = self.env.get(key)
+    return value if value else os.getenv(key)
+
+  def get_llm_api_key(self) -> str:
+    api_key = self.get_env("LLM_API_KEY")
+    if not api_key: raise ValueError("LLM_API_KEY not found in environment variables")
+    return api_key
+
+  def get_mcp_server_config(self) -> dict[str, Any]:
+    with open(self.get_env("MCP_CONFIG_PATH"), "r") as f:
+      return json.load(f)
+

ctools/ai/llm_chat.py

@@ -0,0 +1,168 @@
+from ctools import sys_log
+from ctools.ai.llm_client import LLMClient
+from ctools.ai.mcp.mcp_client import MCPClient, res_has_img, is_image_content, get_tools_prompt, mcp_tool_call
+from ctools.ai.tools.xml_extract import extract_all_xml_blocks
+from ctools.ai.tools.think_process import remove_think_blocks
+
+log = sys_log.flog
+
+continue_prompt_default = """
+1.请继续处理尚未完成的内容,跳过所有已处理完成的部分.
+2.工具调用时,请参考上一次工具调用的参数,仅对偏移量相关的参数进行调整,以接续上一次处理的进度.
+3.如果你认为所有数据都处理完毕, 请输出标记：{end_flag}.
+"""
+
+class ROLE:
+  ASSISTANT = "assistant"
+  USER = "user"
+  SYSTEM = "system"
+
+def get_message_json(role_type: ROLE, content):
+  return {"role": role_type, "content": content}
+
+class ChatSession:
+
+  def __init__(self, prompts: str, llm_client: LLMClient, max_tools_call: int = 10, mcp_clients: list[MCPClient] = None,
+        auto_complete: bool = False, end_flag: str = "EOF", continue_prompt: str = continue_prompt_default) -> None:
+    """
+    初始化聊天
+    :param prompts: 提示词
+    :param llm_client: llm 客户端
+    :param max_tools_call: 最大单次工具调用次数
+    :param mcp_clients: mcp_clients
+    :param auto_complete: 是否自动完成
+    :param end_flag: 结束标记
+    :param continue_prompt: 自动完成时的继续提示
+    """
+    self.mcp_clients: list[MCPClient] = mcp_clients
+    self.llm_client: LLMClient = llm_client
+    self.prompts: str = prompts
+    self.max_tools_call = max_tools_call
+    self.auto_complete = auto_complete
+    self.end_flag = end_flag
+    self.continue_prompt = continue_prompt.format(end_flag=self.end_flag)
+
+    self.current_message = {}
+    self.full_messages = []
+
+  async def init_prompts(self, user_system_prompt):
+    if self.mcp_clients:
+      if user_system_prompt:
+        mcp_tools_prompt = await get_tools_prompt(self.mcp_clients, user_system_prompt)
+      elif self.prompts:
+        mcp_tools_prompt = await get_tools_prompt(self.mcp_clients, self.prompts)
+      else:
+        mcp_tools_prompt = await get_tools_prompt(self.mcp_clients, "")
+      self.full_messages.append(get_message_json(ROLE.SYSTEM, mcp_tools_prompt))
+      #log.info(mcp_tools_prompt)
+    else:
+      if user_system_prompt:
+        self.full_messages.append(get_message_json(ROLE.SYSTEM, user_system_prompt))
+      elif self.prompts:
+        self.full_messages.append(get_message_json(ROLE.SYSTEM, self.prompts))
+
+  async def chat(self, user_input: [str], get_call_id: callable(str) = lambda: "None", get_event_msg_func: callable(str) = None, get_full_msg_func: callable(str) = None):
+    """
+    对话
+    Parameters
+    ----------
+    user_input 用户输入  [{"role": "user", "content": "hello"}]
+    get_call_id 本次对话 ID func
+    get_event_msg_func(get_call_id(), role, msg)    获取实时回复(流式回答)
+    get_full_msg_func(get_call_id(), is_final, msg) 获取完整的回答列表
+    -------
+    """
+    # 获取 prompt
+    user_system_prompt = user_input[0]["content"] if user_input[0]["role"] == "system" else ""
+    user_input = user_input[1:] if user_input[0]["role"] == "system" else user_input
+    await self.init_prompts(user_system_prompt)
+    try:
+      self.full_messages.extend(user_input)
+      last_user_input = next((item["content"] for item in reversed(user_input) if item.get("role") == "user"), None)
+      current_process_index = 0
+      max_tools_call = self.max_tools_call
+      final_resp = False
+      while (current_process_index < max_tools_call and not final_resp) or (self.auto_complete and current_process_index < 100):
+        log.info("\n正在生成回答: %s", self.full_messages)
+        res = []
+        async for chunk in self.llm_client.model_completion(self.full_messages):
+          res.append(chunk)
+          await self.process_chunk_message(chunk, get_call_id, get_event_msg_func)
+        llm_response = "".join(res)
+        log.info("\n收到回答: %s", llm_response)
+        no_think_llm_response = remove_think_blocks(llm_response) # 处理掉 think, 然后再判断 EOF, 避免 think 里出现 EOF
+        if self.end_flag in no_think_llm_response:
+          self.full_messages.append(get_message_json(ROLE.ASSISTANT, llm_response.replace(self.end_flag, ""))) # 去掉 EOF
+          current_process_index = 999
+          final_resp = True
+          await self.process_full_message(final_resp, get_call_id, get_full_msg_func)
+        else:
+          xml_blocks = extract_all_xml_blocks(llm_response)
+          if xml_blocks:
+            for xml_block in xml_blocks:
+              tool_call_result = await mcp_tool_call(self.mcp_clients, xml_block)
+              log.info("\nMCP调用结果: %s", tool_call_result)
+              current_process_index += 1
+              if tool_call_result == xml_block:
+                self.full_messages.append(get_message_json(ROLE.USER, "工具调用出现错误, 请重试."))
+              elif current_process_index == max_tools_call - 1:
+                await self.add_tool_call_res_2_message(last_user_input, tool_call_result)
+                self.full_messages.append(get_message_json(ROLE.USER, "调用次数已达上限, 请直接回答.")) # 不能调换顺序
+              else:
+                self.full_messages.append(get_message_json(ROLE.ASSISTANT, llm_response)) # 不能调换顺序
+                await self.add_tool_call_res_2_message(last_user_input, tool_call_result)
+              await self.process_tool_call_message(get_call_id, get_event_msg_func, tool_call_result)
+            final_resp = False
+          else:
+            self.full_messages.append(get_message_json(ROLE.ASSISTANT, llm_response))
+            if self.auto_complete: self.full_messages.append(get_message_json(ROLE.USER, self.continue_prompt))
+            final_resp = True
+          await self.process_full_message(final_resp, get_call_id, get_full_msg_func)
+    except Exception as e:
+      log.exception(e)
+      error_msg = '系统出现错误, 请重试~ {}'.format(e)
+      self.full_messages.append(get_message_json(ROLE.ASSISTANT, error_msg))
+      await self.process_error_message(error_msg, get_call_id, get_event_msg_func, get_full_msg_func)
+    finally:
+      return self.current_message
+
+  async def process_error_message(self, error_msg, get_call_id, get_event_msg_func, get_full_msg_func):
+    # 最终结果通知前端+实时通知都要有
+    self.current_message = error_msg
+    if get_event_msg_func: await get_event_msg_func(get_call_id(), ROLE.ASSISTANT, self.current_message)
+    if get_full_msg_func: await get_full_msg_func(get_call_id(), True, self.full_messages)
+
+  async def process_chunk_message(self, chunk, get_call_id, get_event_msg_func):
+    # 实时通知前端
+    self.current_message = chunk
+    if get_event_msg_func: await get_event_msg_func(get_call_id(), ROLE.ASSISTANT, self.current_message)
+
+  async def process_tool_call_message(self, get_call_id, get_event_msg_func, tool_call_result):
+    # 实时通知前端(工具调用特殊通知一次) 如果是图片结果, 就是 user 消息(必须是 user, 否则 api 报错), 否则是 system(现在统一都改成 user 了, 看看后面有没有改回 system 的必要)
+    self.current_message = tool_call_result["result"] if res_has_img(tool_call_result) else tool_call_result
+    if get_event_msg_func: await get_event_msg_func(get_call_id(), ROLE.USER, self.current_message)
+
+  async def process_full_message(self, final_resp, get_call_id, get_full_msg_func):
+    if get_full_msg_func: await get_full_msg_func(get_call_id(), final_resp, self.full_messages)
+
+  async def add_tool_call_res_2_message(self, last_user_input, tool_call_result: dict):
+    if type(tool_call_result) != dict: return
+    response:[] = tool_call_result.get("result")
+    image_content = []
+    for rep in response:
+      if not is_image_content(rep):
+        self.full_messages.append(get_message_json(ROLE.USER, str(rep)))
+      else:
+        image_content.append({
+          "type": "image_url",
+          "image_url": {
+            "url": f'data:{rep["mime_type"]};base64,{rep["data"]}'
+          }
+        })
+    if image_content:
+      image_content.append({
+        "type": "text",
+        "text": last_user_input
+      })
+      self.full_messages.append(get_message_json(ROLE.USER, image_content))
+

ctools/ai/llm_client.py

@@ -0,0 +1,133 @@
+import logging
+import os
+import sys
+
+import httpx
+
+from ctools import sys_log, cjson
+
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("mcp.client.sse").setLevel(logging.WARNING)
+
+log = sys_log.flog
+
+def process_SSE(line):
+  if not line: return None
+  if line.startswith("data: "):
+    data = line[6:]
+    if data == "[DONE]":
+      return "DONE"
+    return data
+
+class LLMClient:
+  """Manages communication with the LLM provider."""
+
+  def __init__(self, api_key: str=os.getenv("LLM_API_KEY"),
+               llm_url: str="https://api.siliconflow.cn/v1/",
+               model_name: str="Qwen/Qwen3-235B-A22B",
+               temperature: float=1, stream: bool=True,
+               thinking: bool=True,
+               thinking_budget: int=4096,
+               max_tokens: int=8192,
+               top_p: float=0.5,
+               top_k: int=50,
+               frequency_penalty: float=0.5
+              ) -> None:
+    self.api_key = api_key
+    self.llm_url = llm_url
+    self.model_name = model_name
+    self.temperature = temperature
+    self.stream = stream
+    self.thinking = thinking
+    self.thinking_budget = thinking_budget
+    self.max_tokens = max_tokens
+    self.top_p = top_p
+    self.top_k = top_k
+    self.frequency_penalty = frequency_penalty
+
+  async def model_completion(self, messages: list[dict[str, str]]):
+    self.no_think_compatible(messages)
+    url = self.llm_url
+    headers = {
+      "Content-Type": "application/json",
+      "Authorization": f"Bearer {self.api_key}",
+    }
+    payload = {
+      "messages": messages,
+      "model": self.model_name,
+      "temperature": self.temperature,
+      "max_tokens": self.max_tokens,
+      "top_p": self.top_p,
+      "top_k": self.top_k,
+      "frequency_penalty": self.frequency_penalty,
+      "stream": self.stream,
+      "enable_thinking": self.thinking,
+      "thinking_budget": self.thinking_budget
+    }
+    try:
+      req_url = "chat/completions"
+      if self.stream:
+        async with httpx.AsyncClient(timeout=None, base_url=url) as client:
+          async with client.stream("POST", req_url, headers=headers, json=payload) as response:
+            response.raise_for_status()
+            # 兼容 DS QWEN 的思维链
+            start_think: bool = False
+            end_think: bool = False
+            start_token: str = "<think>"
+            end_token: str = "</think>"
+            # 兼容 DS QWEN 的思维链
+            async for line in response.aiter_lines():
+              data = process_SSE(line)
+              if not data: continue
+              if data == "DONE":
+                continue
+              choice = cjson.loads(data)["choices"][0]
+              if "message" in choice:
+                content = choice["message"]["content"]
+              else:
+                content = choice["delta"].get("content", "")
+                # 兼容 DS QWEN 的思维链
+                reasoning_content = choice["delta"].get("reasoning_content", "")
+                if not start_think and not content and reasoning_content:
+                  content = f"{start_token}{reasoning_content}"
+                  start_think = True
+                if not end_think and start_think and not reasoning_content:
+                  content = f"{end_token}{content}"
+                  end_think = True
+                if not content: content = reasoning_content
+                if not content: continue
+                # 兼容 DS QWEN 的思维链
+              yield content
+      else:
+        async with httpx.AsyncClient(timeout=None, base_url=url) as client:
+          response = await client.post(req_url, headers=headers, json=payload)
+          response.raise_for_status()
+          content = response.json()["choices"][0]["message"]["content"]
+          yield content
+    except httpx.RequestError as e:
+      error_message = f"Error getting LLM response: {str(e)}"
+      log.error(error_message)
+      if isinstance(e, httpx.HTTPStatusError):
+        status_code = e.response.status_code
+        log.error(f"Status code: {status_code}")
+        log.error(f"Response details: {e.response.text}")
+      yield f"I encountered an error: {error_message}. Please try again or rephrase your request."
+
+  def no_think_compatible(self, messages):
+    if not self.thinking and "qwen3" in self.model_name:
+      for msg in messages:
+        if (msg.get("role") == "user" or msg.get("role") == "system") and "/no_think" not in msg.get("content", ""):
+          msg["content"] += " /no_think"
+
+# if __name__ == '__main__':
+#   from env_config import Configuration
+#
+#   config = Configuration()
+#   # llm = LLMClient(config.get_llm_api_key(), llm_url="http://192.168.3.73:8000/v1/", stream=True, model_name="deepseek-r1:7b", thinking=False, verbose=True)
+#   llm = LLMClient(config.get_llm_api_key(), stream=True, model_name="Qwen/Qwen3-32B", thinking=False, verbose=True)
+#   res = []
+#   for chunk in llm.get_response([{"role": "user", "content": "写一个大概三百字的开心故事"}]):
+#     res.append(chunk)
+#   print("".join(res))
+

ctools/ai/mcp/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/5/22 15:56'

ctools/ai/mcp/mcp_client.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/5/16 16:49'
+
+import asyncio
+import json
+import shutil
+from contextlib import AsyncExitStack, asynccontextmanager
+from typing import Any
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.sse import sse_client
+from mcp.client.stdio import stdio_client
+from mcp.client.streamable_http import streamablehttp_client
+from mcp.types import CallToolResult, TextContent, ImageContent
+
+from ctools import sys_log
+from ctools.ai.tools.tool_use_xml_parse import parse_tool_use
+
+log = sys_log.flog
+
+sys_prompt_4_mcp = """
+1. In this environment you have access to a set of tools you can use to answer the user's question.
+2. You can use one tool per message, and will receive the result of that tool use in the user's response.
+3. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+4. Before solving the task, break it down into clear, logical steps. List and number the steps first. Then, execute them one by one, There is no need to explain each step as you go. Do not skip any steps. Wait for confirmation before proceeding to the next step, if needed.
+
+## Tool Use Formatting
+
+Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
+<tool_use>
+<name>{{tool_name}}</name>
+<arguments>{{json_arguments}}</arguments>
+</tool_use>
+
+The tool name should be the exact name of the tool you are using, and the arguments should be a JSON object containing the parameters required by that tool. For example:
+
+<tool_use>
+  <name>say_hello</name>
+  <arguments>
+    {{
+      "content": "你好"
+    }}
+  </arguments>
+</tool_use>
+
+The result should be a string, which can represent a file or any other output type. You can use this result as input for the next action.
+
+Always adhere to this format for the tool use to ensure proper parsing and execution.
+
+## Tool Use Available Tools
+Above example were using notional tools that might not exist for you. You only have access to these tools:
+{tools_description}
+
+## Tool Use Rules
+Here are the rules you should always follow to solve your task:
+1. Always use the right arguments for the tools. Never use variable names as the action arguments, use the value instead.
+2. Call a tool only when needed: do not call the search agent if you do not need information, try to solve the task yourself.
+3. If no tool call is needed, just answer the question directly.
+4. Never re-do a tool call that you previously did with the exact same parameters.
+5. For tool use, MARK SURE use XML tag format as shown in the examples above. Do not use any other format.
+6. Parameter passing should never escape unicode, and this is done by default, do not convert Chinese to Unicode escape characters
+
+# User Instructions
+{user_system_prompt}
+
+Now Begin! If you solve the task correctly, you will receive a reward of $1,000,000.
+"""
+
+tools_use_example = """
+Here are a few examples using notional tools:
+
+---
+User: "What is the result of the following operation: 5 + 3 + 1294.678?"
+
+Assistant: I can use the python_interpreter tool to calculate the result of the operation.
+<tool_use>
+  <name>python_interpreter</name>
+  <arguments>{"code": "5 + 3 + 1294.678"}</arguments>
+</tool_use>
+
+User: {
+  "tool_name": "python_interpreter",
+  "result": ["1302.678"]
+}
+
+Assistant: The result of the operation is 1302.678.
+
+---
+User: "Which city has the highest population , Guangzhou or Shanghai?"
+
+Assistant: I can use the search tool to find the population of Guangzhou.
+<tool_use>
+  <name>search</name>
+  <arguments>{"query": "Population Guangzhou"}</arguments>
+</tool_use>
+
+User: {
+  "tool_name": "search",
+  "result": ["Guangzhou has a population of 15 million inhabitants as of 2021."]
+}
+
+Assistant: I can use the search tool to find the population of Shanghai.
+<tool_use>
+  <name>search</name>
+  <arguments>{"query": "Population Shanghai"}</arguments>
+</tool_use>
+
+User: {
+  "tool_name": "search",
+  "result": ["26 million (2019)"]
+}
+Assistant: The population of Shanghai is 26 million, while Guangzhou has a population of 15 million. Therefore, Shanghai has the highest population.
+"""
+
+async def get_tools_prompt(mcp_clients, user_system_prompt) -> str:
+  all_tools = []
+  for client in mcp_clients:
+    tools = await client.list_server_tools()
+    all_tools.extend(tools)
+  return sys_prompt_4_mcp.format(tools_description="\n".join([tool.format_for_llm() for tool in all_tools]), user_system_prompt=user_system_prompt)
+
+class Tool:
+
+  def __init__(self, name: str, description: str, input_schema: dict[str, Any]) -> None:
+    self.name: str = name
+    self.description: str = description
+    self.input_schema: dict[str, Any] = input_schema
+
+  def format_for_llm(self) -> str:
+    args_desc = []
+    if "properties" in self.input_schema:
+      for param_name, param_info in self.input_schema["properties"].items():
+        arg_desc = f"- {param_name}({param_info.get('type', 'Any')}):  {param_info.get('description', '')}"
+        if param_name in self.input_schema.get("required", []):
+          arg_desc += " (required)"
+        args_desc.append(arg_desc)
+    return f"""
+Tool: {self.name}
+Description: {self.description}
+Args_Info:
+{chr(10).join(args_desc)}
+"""
+
+class MCPClient:
+
+  def __init__(self, name: str, config: dict[str, Any]) -> None:
+    self.name: str = name
+    self.config: dict[str, Any] = config
+    self.stdio_context: Any | None = None
+    self.session: ClientSession | None = None
+    self.exit_stack: AsyncExitStack = AsyncExitStack()
+    self.tools = []
+
+  async def initialize(self) -> None:
+    if self.config.get('server_type') is None or self.config.get('server_type') == 'stdio':
+      command = (shutil.which("npx") if self.config["command"] == "npx" else self.config["command"])
+      if command is None: raise ValueError("The command must be a valid string and cannot be None.")
+      server_params = StdioServerParameters(
+        command=command,
+        args=self.config["args"],
+        env=self.config["env"] if self.config.get("env") else None,
+      )
+      stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+      read, write = stdio_transport
+      self.session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+      await self.session.initialize()
+    elif self.config['server_type'] == 'SSE':
+      sse_transport = await self.exit_stack.enter_async_context(sse_client(
+        url=self.config["url"],
+        headers=self.config["headers"],
+        timeout=self.config["timeout"],
+        sse_read_timeout=self.config["sse_read_timeout"]))
+      read, write = sse_transport
+      self.session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+      await self.session.initialize()
+    elif self.config['server_type'] == 'Streamable HTTP':
+      stream_transport = await self.exit_stack.enter_async_context(streamablehttp_client(
+        url=self.config["url"],
+        headers=self.config["headers"],
+        timeout=self.config["timeout"],
+        sse_read_timeout=self.config["sse_read_timeout"]))
+      read, write, session_id = stream_transport
+      self.session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+      await self.session.initialize()
+
+  async def list_server_tools(self) -> list[Any]:
+    if not self.session: raise RuntimeError(f"Server {self.name} not initialized")
+    if self.tools: return self.tools
+    tools_response = await self.session.list_tools()
+    for item in tools_response:
+      if isinstance(item, tuple) and item[0] == "tools":
+        self.tools.extend(Tool(tool.name, tool.description, tool.inputSchema) for tool in item[1])
+    return self.tools
+
+  async def execute_tool(
+    self,
+    tool_name: str,
+    arguments: dict[str, Any],
+    retries: int = 3,
+    delay: float = 1.0,
+  ) -> Any:
+    if not self.session: raise RuntimeError(f"Server {self.name} not initialized")
+    attempt = 0
+    args = arguments
+    while attempt < retries:
+      try:
+        log.info(f"Executing {tool_name}...")
+        result = await self.session.call_tool(tool_name, args)
+        return result
+      except Exception as e:
+        attempt += 1
+        log.warning(f"Error executing tool: {e}. Attempt {attempt} of {retries}.")
+        if attempt < retries:
+          log.info(f"Retrying in {delay} seconds...")
+          await asyncio.sleep(delay)
+        else:
+          log.error("Max retries reached. Failing.")
+          raise
+
+  async def cleanup(self) -> None:
+    await self.exit_stack.aclose()
+    self.session = None
+    self.stdio_context = None
+    self.exit_stack = None
+
+
+async def mcp_tool_call(mcp_clients: MCPClient, xml_info: str) -> str:
+  if not mcp_clients: return xml_info
+  final_result = {
+    "tool_name": "",
+    "result": []
+  }
+  try:
+    tool_call = parse_tool_use(xml_info)
+    if "tool" in tool_call and "arguments" in tool_call:
+      log.info(f"Executing tool: {tool_call['tool']} With arguments: {tool_call['arguments']}")
+      for client in mcp_clients:
+        tools = await client.list_server_tools()
+        if any(tool.name == tool_call["tool"] for tool in tools):
+          final_result["tool_name"] = tool_call["tool"]
+          try:
+            result: CallToolResult = await client.execute_tool(tool_call["tool"], tool_call["arguments"])
+            text_result = []
+            image_result = []
+            tools_call_content = result.content
+            for content in tools_call_content:
+              if type(content) == TextContent:
+                try:
+                  text_result.append(json.loads(content.text))
+                except Exception as e:
+                  text_result.append(content.text)
+              elif type(content) == ImageContent:
+                image_result.append({"mime_type": content.mimeType, "data": content.data})
+            text_result.extend(image_result)
+            final_result["result"] = text_result
+            return final_result
+          except Exception as e:
+            log.exception(e)
+            error_msg = f"Error executing tool: {str(e)}"
+            final_result["result"] = [error_msg]
+            return final_result
+      return f"No server found with tool: {tool_call['tool']}"
+    return xml_info
+  except Exception as e:
+    log.exception(e)
+    error_msg = f"Error executing tool: {str(e)}"
+    final_result["result"] = [error_msg]
+    return final_result
+
+def res_has_img(llm_response) -> bool:
+  if type(llm_response) == str: return False
+  response: [] = llm_response.get("result")
+  for rep in response:
+    if is_image_content(rep):
+      return True
+  return False
+
+def is_image_content(content: dict) -> bool:
+  try:
+    if content.get("mime_type") and content.get("data"):
+      return True
+    return False
+  except Exception:
+    return False
+
+@asynccontextmanager
+async def init_mcp_clients(mcp_server_config: dict[str, Any]) -> list[MCPClient]:
+  mcp_clients = []
+  for name, sc in mcp_server_config["mcpServers"].items():
+    try:
+      mc = MCPClient(name, sc)
+      await mc.initialize()
+      mcp_clients.append(mc)
+    except Exception as e:
+      log.exception(f"Error initializing MCP servers: {e}")
+  yield mcp_clients
+  for client in mcp_clients:
+    try:
+      print(client.name)
+      await client.cleanup()
+    except Exception as e:
+      log.exception(f"Error unloading MCP servers: {e}")
+

ctools/ai/tools/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/5/22 15:57'