Commit 0e965fc

@@ -6,7 +6,7 @@ from openai import DefaultAsyncHttpxClient
 from pyrogram.types import Message
 
 from config import GPT, PROXY
-from llm.prompts import force_reasoning, refine_prompts
+from llm.prompts import refine_prompts
 from messages.parser import parse_msg
 from utils import unicode_to_ascii
 
@@ -88,12 +88,10 @@ def get_model_config_with_contexts(model_type: str, contexts: list[dict], force_
         client["api_key"] = GPT.LONG_API_KEY
         client["base_url"] = GPT.LONG_BASE_URL
         model_name = GPT.LONG_MODEL_NAME
-    client = helicone_hook(client, message_info)  # this line should be after setting `force_model``
 
     # params for `openai.chat.completions.create()`
     completions = {"model": model, "messages": contexts, "temperature": float(GPT.TEMPERATURE)}
-    completions = model_hook(completions)
-    completions |= openrouter_hook(client["base_url"])  # this line should be after setting `force_model``
+    hooks(client, completions, message_info)  # this line should be after setting `force_model``
     completions["messages"] = refine_prompts(completions["messages"])  # final refine after hooks
 
     if force_model != "N/A" and completions.get("extra_body"):  # remove models fallback
@@ -105,10 +103,15 @@ def get_model_config_with_contexts(model_type: str, contexts: list[dict], force_
     }
 
 
-def openrouter_hook(base_url: str, *, for_tools: bool = False) -> dict:
+def hooks(client: dict, completions: dict, message_info: dict | None = None, *, for_tools: bool = False):
+    openrouter_hook(client, completions, for_tools=for_tools)
+    helicone_hook(client, message_info)
+
+
+def openrouter_hook(client: dict, completions: dict, *, for_tools: bool = False) -> None:
     """Add special parameters for OpenRouter."""
-    if "openrouter" not in base_url:
-        return {}
+    if "openrouter" not in client["base_url"]:
+        return
     params: dict[str, Any] = {"extra_body": {"provider": {"sort": "throughput"}}}
     if for_tools:
         if models := [x.strip() for x in GPT.FALLBACK_TOOLS_MODELS.split(",") if x.strip()]:
@@ -117,13 +120,13 @@ def openrouter_hook(base_url: str, *, for_tools: bool = False) -> dict:
         params["extra_body"] |= {"include_reasoning": True}
         if models := [x.strip() for x in GPT.FALLBACK_MODELS.split(",") if x.strip()]:
             params["extra_body"] |= {"models": models}
-    return params
+    completions |= params
 
 
-def helicone_hook(client: dict, message_info: dict | None) -> dict:
+def helicone_hook(client: dict, message_info: dict | None) -> None:
     """Add special parameters for helicone gateway."""
     if not GPT.HELICONE_API_KEY:
-        return client
+        return
     headers = client.get("default_headers", {})
     headers |= {
         "Helicone-Auth": f"Bearer {GPT.HELICONE_API_KEY}",
@@ -133,9 +136,4 @@ def helicone_hook(client: dict, message_info: dict | None) -> dict:
         headers |= {"Helicone-Property-Chat": unicode_to_ascii(chat_title), "Helicone-Property-ChatID": str(message_info["cid"])}
     if user_name := message_info.get("full_name"):
         headers |= {"Helicone-User-Id": unicode_to_ascii(user_name), "Helicone-Property-User": str(message_info["uid"])}
-    return client | {"default_headers": headers}
-
-
-def model_hook(params: dict) -> dict:
-    """Add parameters for special models."""
-    return force_reasoning(params)
+    client |= {"default_headers": headers}

@@ -3,11 +3,9 @@
 
 from loguru import logger
 
-from config import GPT, TZ
+from config import TZ
 from utils import nowdt
 
-REASONING_PROMPT = "In every output, response using the following format:\n<think>\n{reasoning_content}\n</think>\n\n{content}"
-
 
 # ruff: noqa: RUF001
 def modify_prompts(context: list[dict], prompt: str, role: str = "system", method: str = "overwrite") -> list[dict]:
@@ -31,30 +29,6 @@ def modify_prompts(context: list[dict], prompt: str, role: str = "system", metho
     return context
 
 
-def force_reasoning(params: dict) -> dict:
-    """Force model reasoning.
-
-    Although the official instructions do not add system prompt [1],
-    we found that add the following system prompt is much better [2].
-
-    # Ref-1: https://github.com/deepseek-ai/DeepSeek-R1/tree/ef99616?tab=readme-ov-file#usage-recommendations
-    # Ref-2: https://linux.do/t/topic/408247
-    """
-    model = params.get("model", "").lower()
-    reasoning_models = [x.strip() for x in GPT.REASONING_MODELS.split(",") if x.strip()]
-    # remove previous thinking prompt
-    # params["messages"] = remove_prompt_from_contexts(params["messages"], REASONING_PROMPT)
-
-    if any(x in model for x in reasoning_models):
-        params["messages"] = modify_prompts(
-            params["messages"],
-            prompt=REASONING_PROMPT,
-            role="system",
-            method="prepend",
-        )
-    return params
-
-
 def add_search_results_to_prompts(search_results: list[dict], params: dict) -> dict:
     """Add search results to contexts.
 

@@ -8,7 +8,7 @@ from loguru import logger
 from openai import AsyncOpenAI, DefaultAsyncHttpxClient
 
 from config import GPT, PROXY, TOKEN, TZ
-from llm.models import openrouter_hook
+from llm.models import hooks
 from llm.prompts import add_search_results_to_prompts, modify_prompts
 from llm.response import send_to_gpt
 from llm.tool_scheme import ONLINE_SEARCH
@@ -138,15 +138,17 @@ async def merge_tools_response(config: dict, **kwargs) -> tuple[dict, dict]:
     if any(x in config["completions"]["model"].lower() for x in ["search", "搜索"]):  # skip search model
         return config, {}
     # tool model should be fast and cheap
-    completions = {
+    tool_completions = {
         "model": GPT.TOOLS_MODEL,
         "messages": copy.deepcopy(config["completions"]["messages"]),
     }
-    completions |= openrouter_hook(GPT.TOOLS_BASE_URL, for_tools=True)
+    tool_completions = add_tools(tool_completions)
+    tool_client = {k: v for k, v in config["client"].items() if k != "http_client"} | {"base_url": GPT.TOOLS_BASE_URL, "api_key": GPT.TOOLS_API_KEY}
+    hooks(tool_client, tool_completions, for_tools=True)
     tools_config = {
         "friendly_name": config["friendly_name"],
-        "client": config["client"] | {"base_url": GPT.TOOLS_BASE_URL, "api_key": GPT.TOOLS_API_KEY},
-        "completions": add_tools(completions),
+        "client": tool_client,
+        "completions": tool_completions,
     }
     try:
         response = await send_to_gpt(tools_config, retry=0)