gomyck-tools 1.0.0__py3-none-any.whl → 1.4.7__py3-none-any.whl

ctools/__init__.py

@@ -0,0 +1,21 @@
+import asyncio
+import importlib.util
+
+banner = """
+
+ ██████╗████████╗ ██████╗  ██████╗ ██╗     ███████╗
+██╔════╝╚══██╔══╝██╔═══██╗██╔═══██╗██║     ██╔════╝
+██║        ██║   ██║   ██║██║   ██║██║     ███████╗
+██║        ██║   ██║   ██║██║   ██║██║     ╚════██║
+╚██████╗   ██║   ╚██████╔╝╚██████╔╝███████╗███████║
+ ╚═════╝   ╚═╝    ╚═════╝  ╚═════╝ ╚══════╝╚══════╝   --by gomyck 2025
+"""
+
+print(banner)
+
+if importlib.util.find_spec("uvloop"):
+  import uvloop
+  asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+  print("uvloop version:", uvloop.__version__)
+else:
+  print("uvloop not installed, using default asyncio loop")

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/llm_chat.py

@@ -0,0 +1,184 @@
+from ctools import sys_log
+from ctools.ai.llm_client import LLMClient
+from ctools.ai.llm_exception import LLMException
+from ctools.ai.mcp.mcp_client import MCPClient, res_has_img, is_image_content, get_tools_prompt, mcp_tool_call
+from ctools.ai.tools.quick_tools import build_message, ROLE
+from ctools.ai.tools.think_process import remove_think_blocks
+from ctools.ai.tools.xml_extract import extract_all_xml_blocks
+
+log = sys_log.flog
+
+continue_prompt_default = """
+1.请继续处理尚未完成的内容,跳过所有已处理完成的部分.
+2.工具调用时,请参考上一次工具调用的参数,仅对偏移量相关的参数进行调整,以接续上一次处理的进度.
+3.如果你认为所有数据都处理完毕, 请输出标记：{end_flag}.
+"""
+
+
+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 = []
+    self.res_code = 200
+
+  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(build_message(ROLE.SYSTEM, mcp_tools_prompt))
+      # log.info(mcp_tools_prompt)
+    else:
+      if user_system_prompt:
+        self.full_messages.append(build_message(ROLE.SYSTEM, user_system_prompt))
+      elif self.prompts:
+        self.full_messages.append(build_message(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
+    if type(user_input) == dict: user_input = [user_input]
+    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(build_message(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(build_message(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(build_message(ROLE.USER, "调用次数已达上限, 请直接回答."))  # 不能调换顺序
+              else:
+                self.full_messages.append(build_message(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(build_message(ROLE.ASSISTANT, llm_response))
+            if self.auto_complete: self.full_messages.append(build_message(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)
+      if isinstance(e, LLMException):
+        error_code = e.code
+        error_msg = '系统出现错误, 请重试: {}-{}'.format(e.code, e.message)
+      else:
+        error_code = 500
+        error_msg = '系统出现错误, 请重试: {}'.format(e)
+      self.full_messages.append(build_message(ROLE.ASSISTANT, error_msg))
+      await self.process_error_message(error_code, error_msg, get_call_id, get_event_msg_func, get_full_msg_func)
+    finally:
+      return self.current_message
+
+  async def process_error_message(self, code, error_msg, get_call_id, get_event_msg_func, get_full_msg_func):
+    # 最终结果通知前端+实时通知都要有
+    self.res_code = code
+    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):
+    """
+    全量消息回调函数
+    :param final_resp: 最终响应信息
+    :param get_call_id: 调用 ID
+    :param get_full_msg_func: 回调的函数
+    """
+    self.current_message = self.full_messages[-1]["content"]
+    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):
+    """
+    添加当前会话结果, 以便于用当前 chat 对象取值
+    :param last_user_input: 客户端最后一次输入
+    :param tool_call_result: 工具调用结果
+    """
+    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(build_message(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(build_message(ROLE.USER, image_content))

ctools/ai/llm_client.py

@@ -0,0 +1,163 @@
+import logging
+import os
+
+import httpx
+
+from ctools import sys_log, cjson, call
+from ctools.util.env_config import float_env, bool_env, int_env
+from ctools.ai.llm_exception import LLMException
+
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("mcp.client.sse").setLevel(logging.WARNING)
+
+log = sys_log.flog
+shared_client = None
+
+def process_SSE(line):
+  if not line: return None
+  if line.startswith("data: "):
+    data = line[6:]
+    if data == "[DONE]":
+      return "[DONE]"
+    return data
+
+@call.once
+def init_shared_client():
+  global shared_client
+  shared_client = httpx.AsyncClient(
+    base_url=os.getenv("LLM_BASE_URL", "https://api.siliconflow.cn/v1/"),
+    timeout=httpx.Timeout(connect=10.0, read=60.0, write=10.0, pool=5.0),
+    limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
+  )
+  return shared_client
+
+class LLMClient:
+  """Manages communication with the LLM provider."""
+
+  def __init__(self,
+     api_key: str = "",
+     model_name: str = "",
+     temperature: float = None,
+     stream: bool = None,
+     thinking: bool = None,
+     thinking_budget: int = None,
+     max_tokens: int = None,
+     top_p: float = None,
+     top_k: int = None,
+     frequency_penalty: float = None
+   ) -> None:
+    self.api_key = api_key or os.getenv("LLM_API_KEY")
+    self.model_name = model_name or os.getenv("LLM_MODEL_NAME", "Qwen/Qwen3-235B-A22B")
+    self.temperature = temperature or float_env("LLM_TEMPERATURE", 0.8)
+    self.stream = stream or bool_env("LLM_STREAM", True)
+    self.thinking = thinking or bool_env("LLM_THINKING", True)
+    self.thinking_budget = thinking_budget or int_env("LLM_THINKING_BUDGET", 4096)
+    self.max_tokens = max_tokens or int_env("LLM_MAX_TOKENS", 4096)
+    self.top_p = top_p or float_env("LLM_TOP_P", 0.5)
+    self.top_k = top_k or int_env("LLM_TOP_K", 50)
+    self.frequency_penalty = frequency_penalty or float_env("LLM_FREQUENCY_PENALTY", 0)
+    init_shared_client()
+
+  async def model_completion(self, messages: list[dict[str, str]]):
+    self.no_think_compatible(messages)
+    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 shared_client.stream("POST", req_url, headers=headers, json=payload) as response:
+          response.raise_for_status()
+          start_think = False
+          end_think = False
+          async for line in response.aiter_lines():
+            data = process_SSE(line)
+            if not data or data == "[DONE]":
+              continue
+            choice = cjson.loads(data)["choices"][0]
+            if "message" in choice:
+              content = choice["message"]["content"]
+            else:
+              content = choice["delta"].get("content", "")
+              reasoning_content = choice["delta"].get("reasoning_content", "")
+              if not start_think and not content and reasoning_content:
+                content = f"<think>{reasoning_content}"
+                start_think = True
+              if not end_think and start_think and not reasoning_content:
+                content = f"</think>{content}"
+                end_think = True
+              if not content:
+                content = reasoning_content
+            if content:
+              yield content
+      else:
+        response = await shared_client.post(req_url, headers=headers, json=payload)
+        response.raise_for_status()
+        content = response.json()["choices"][0]["message"]["content"]
+        yield content
+    except Exception as e:
+      error_message = f"Error getting LLM response: {str(e)}"
+      log.error(error_message)
+      if isinstance(e, httpx.ReadTimeout):
+        raise LLMException(code=500, message="模型访问超时")
+      if isinstance(e, httpx.HTTPStatusError):
+        log.error(f"Status code: {e.response.status_code}")
+        log.error(f"Response details: {e.response.text}")
+        raise LLMException(e.response.status_code, e.response.text)
+      raise LLMException(code=500, message=error_message)
+
+  def no_think_compatible(self, messages):
+    if not self.thinking and "qwen3" in self.model_name.lower():
+      for msg in messages:
+        if msg and msg.get("role") in ("user", "system") and "/no_think" not in msg.get("content", ""):
+          msg["content"] += " /no_think"
+
+  async def voice_2_text(self, file: bytes = None, file_path: str = None):
+    try:
+      if file_path:
+        with open(file_path, "rb") as f:
+          file = f.read()
+      req_url = "/audio/transcriptions"
+      headers = {
+        "Authorization": f"Bearer {self.api_key}",
+      }
+      files = {
+        "model": (None, self.model_name),
+        "file": ("audio.wav", file, "audio/wav"),
+      }
+      response = await shared_client.post(req_url, headers=headers, files=files)
+      response.raise_for_status()
+      return response.json()["text"]
+    except Exception as e:
+      error_message = f"Error getting LLM response: {str(e)}"
+      log.error(error_message)
+      if isinstance(e, httpx.HTTPStatusError):
+        log.error(f"Status code: {e.response.status_code}")
+        log.error(f"Response details: {e.response.text}")
+        raise LLMException(e.response.status_code, e.response.text)
+      raise LLMException(code=500, message=error_message)
+
+# from env_config import Configuration
+# config = Configuration("/Users/haoyang/work/pycharmWorkspace/gomyck-py-plugins/ai/klmy-entry_get/.env")
+#
+# async def run():
+#   llm = LLMClient(config.get_llm_api_key(), model_name="FunAudioLLM/SenseVoiceSmall")
+#   res = await llm.voice_2_text(file_path="/Users/haoyang/Downloads/audio.wav")
+#   print(res)
+#
+# if __name__ == '__main__':
+#   asyncio.run(run())

ctools/ai/llm_exception.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/6/9 09:02'
+
+from ctools.web.api_result import R
+
+
+class LLMException(Exception):
+
+  def __init__(self, code, message):
+    super(LLMException, self).__init__(message)
+    self.code = code
+    self.message = message
+
+  def __str__(self):
+    return R.error(resp=R.Code.cus_code(self.code, self.message))

ctools/ai/mcp/__init__.py

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