gomyck-tools 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

ctools/ai/env_config.py

@@ -20,6 +20,8 @@ class Configuration:
 
   def get_env(self, key: str) -> str:
     value = self.env.get(key)
+    if value and value.lower() == "true": return True
+    if value and value.lower() == "false": return False
     return value if value else os.getenv(key)
 
   def get_llm_api_key(self) -> str:

ctools/ai/llm_chat.py

@@ -1,8 +1,10 @@
 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.xml_extract import extract_all_xml_blocks
+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
 
@@ -12,14 +14,6 @@ continue_prompt_default = """
 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,
@@ -44,7 +38,7 @@ class ChatSession:
 
     self.current_message = {}
     self.full_messages = []
-    self.is_success = True
+    self.res_code = 200
 
   async def init_prompts(self, user_system_prompt):
     if self.mcp_clients:
@@ -54,13 +48,13 @@ class ChatSession:
         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))
+      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(get_message_json(ROLE.SYSTEM, user_system_prompt))
+        self.full_messages.append(build_message(ROLE.SYSTEM, user_system_prompt))
       elif self.prompts:
-        self.full_messages.append(get_message_json(ROLE.SYSTEM, 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):
     """
@@ -74,6 +68,7 @@ class ChatSession:
     -------
     """
     # 获取 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)
@@ -93,7 +88,7 @@ class ChatSession:
         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
+          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)
@@ -105,31 +100,36 @@ class ChatSession:
               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, "工具调用出现错误, 请重试."))
+                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(get_message_json(ROLE.USER, "调用次数已达上限, 请直接回答.")) # 不能调换顺序
+                self.full_messages.append(build_message(ROLE.USER, "调用次数已达上限, 请直接回答.")) # 不能调换顺序
               else:
-                self.full_messages.append(get_message_json(ROLE.ASSISTANT, llm_response)) # 不能调换顺序
+                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(get_message_json(ROLE.ASSISTANT, llm_response))
-            if self.auto_complete: self.full_messages.append(get_message_json(ROLE.USER, self.continue_prompt))
+            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)
-      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)
+      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, error_msg, get_call_id, get_event_msg_func, get_full_msg_func):
+  async def process_error_message(self, code, error_msg, get_call_id, get_event_msg_func, get_full_msg_func):
     # 最终结果通知前端+实时通知都要有
-    self.is_success = False
+    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)
@@ -145,6 +145,7 @@ class ChatSession:
     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):
+    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):
@@ -153,7 +154,7 @@ class ChatSession:
     image_content = []
     for rep in response:
       if not is_image_content(rep):
-        self.full_messages.append(get_message_json(ROLE.USER, str(rep)))
+        self.full_messages.append(build_message(ROLE.USER, str(rep)))
       else:
         image_content.append({
           "type": "image_url",
@@ -166,5 +167,5 @@ class ChatSession:
         "type": "text",
         "text": last_user_input
       })
-      self.full_messages.append(get_message_json(ROLE.USER, image_content))
+      self.full_messages.append(build_message(ROLE.USER, image_content))
 

ctools/ai/llm_client.py

@@ -1,10 +1,10 @@
 import logging
 import os
-import sys
 
 import httpx
 
 from ctools import sys_log, cjson
+from ctools.ai.llm_exception import LLMException
 
 logging.getLogger("httpcore").setLevel(logging.WARNING)
 logging.getLogger("httpx").setLevel(logging.WARNING)
@@ -17,25 +17,31 @@ def process_SSE(line):
   if line.startswith("data: "):
     data = line[6:]
     if data == "[DONE]":
-      return "DONE"
+      return "[DONE]"
     return data
 
+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),
+)
+
 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:
+  def __init__(self,
+    api_key: str = os.getenv("LLM_API_KEY"),
+    model_name: str = "Qwen/Qwen3-235B-A22B",
+    temperature: float = 1,
+    stream: bool = False,
+    thinking: bool = True,
+    thinking_budget: int = 4096,
+    max_tokens: int = 4096,
+    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
@@ -48,7 +54,6 @@ class LLMClient:
 
   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}",
@@ -68,66 +73,82 @@ class LLMClient:
     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 的思维链
+        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:
-        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:
+        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.HTTPStatusError):
-        status_code = e.response.status_code
-        log.error(f"Status code: {status_code}")
+        log.error(f"Status code: {e.response.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."
+        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:
+    if not self.thinking and "qwen3" in self.model_name.lower():
       for msg in messages:
-        if (msg.get("role") == "user" or msg.get("role") == "system") and "/no_think" not in msg.get("content", ""):
+        if msg.get("role") in ("user", "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))
+  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/mcp_client.py

@@ -5,6 +5,7 @@ __date__ = '2025/5/16 16:49'
 
 import asyncio
 import json
+import os
 import shutil
 from contextlib import AsyncExitStack, asynccontextmanager
 from typing import Any
@@ -157,10 +158,13 @@ class MCPClient:
     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.")
+      env = os.environ.copy()
+      custom_env = self.config.get("env", {})
+      env.update(custom_env)
       server_params = StdioServerParameters(
         command=command,
         args=self.config["args"],
-        env=self.config["env"] if self.config.get("env") else None,
+        env=env,
       )
       stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
       read, write = stdio_transport

ctools/ai/tools/quick_tools.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/6/9 09:49'
+
+import asyncio
+import json
+import sys
+import uuid
+
+from aiohttp import web
+
+import base64
+import mimetypes
+
+class ROLE:
+  ASSISTANT = "assistant"
+  USER = "user"
+  SYSTEM = "system"
+
+def build_message(role_type: ROLE, content):
+  return {"role": role_type, "content": content}
+
+def build_image_message(content: str, file: bytes=None, file_path: str=None):
+  rep = _get_image_data_and_mime(file, file_path)
+  img_content = [{
+    "type": "image_url",
+    "image_url": {
+      "url": f'data:{rep["mime_type"]};base64,{rep["data"]}'
+    }
+  }, {
+    "type": "text",
+    "text": content
+  }]
+  return build_message(ROLE.USER, img_content)
+
+def build_call_back(debug=False):
+  call_id = uuid.uuid4()
+  queue = asyncio.Queue()
+  async def on_msg(cid, role, msg):
+    if debug: print(msg, file=sys.__stdout__, end='')
+    await queue.put({"id": cid, "role": role, "msg": msg})
+  async def on_final(cid, is_final, msg):
+    if debug: print(cid, is_final, msg, file=sys.__stdout__)
+    if is_final:
+      await queue.put("[DONE]")
+    else:
+      nonlocal call_id
+      call_id = uuid.uuid4()
+  def get_call_id():
+    return call_id.hex
+  async def process_sse_resp(response: web.StreamResponse, e: Exception = None):
+    if e:
+      await response.write(b"data: " + f'{{"code": 500, "error": "{e}"}}'.encode('utf-8') + b"\n\n")
+      await response.write(b"data: [DONE]\n\n")
+      return
+    while True:
+      msg = await queue.get()
+      if msg == "[DONE]":
+        await response.write(b"data: [DONE]\n\n")
+        break
+      await response.write(f"data: {json.dumps(msg)}\n\n".encode("utf-8"))
+  return process_sse_resp, {"get_call_id": get_call_id, "get_event_msg_func": on_msg, "get_full_msg_func": on_final}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def _get_image_data_and_mime(file: bytes = None, file_path: str = None):
+  if file_path:
+    with open(file_path, "rb") as f:
+      file = f.read()
+  if not file:
+    raise ValueError("file 和 file_path 至少要提供一个")
+  mime_type = "application/octet-stream"
+  if file_path:
+    mime_type_guess, _ = mimetypes.guess_type(file_path)
+    if mime_type_guess:
+      mime_type = mime_type_guess
+  data = base64.b64encode(file).decode("utf-8")
+  return {
+    "mime_type": mime_type,
+    "data": data
+  }

ctools/ai/tools/xml_extract.py

@@ -8,6 +8,5 @@ text = """
 """
 
 results = extract_all_xml_blocks(text)
-print(results)
 for xml_block in results:
   print(xml_block)