khoj 2.0.0b14.dev43__py3-none-any.whl → 2.0.0b15.dev22__py3-none-any.whl

khoj/processor/conversation/google/gemini_chat.py

@@ -1,22 +1,16 @@
 import logging
-from datetime import datetime
-from typing import AsyncGenerator, Dict, List, Optional
+from typing import AsyncGenerator, List, Optional
+
+from langchain_core.messages.chat import ChatMessage
 
-from khoj.database.models import Agent, ChatMessageModel, ChatModel
-from khoj.processor.conversation import prompts
 from khoj.processor.conversation.google.utils import (
     gemini_chat_completion_with_backoff,
     gemini_completion_with_backoff,
 )
 from khoj.processor.conversation.utils import (
-    OperatorRun,
     ResponseWithThought,
-    generate_chatml_messages_with_context,
     messages_to_print,
 )
-from khoj.utils.helpers import is_none_or_empty, truncate_code_context
-from khoj.utils.rawconfig import FileAttachment, LocationData
-from khoj.utils.yaml import yaml_dump
 
 logger = logging.getLogger(__name__)
 
@@ -61,95 +55,18 @@ def gemini_send_message_to_model(
 
 async def converse_gemini(
     # Query
-    user_query: str,
-    # Context
-    references: list[dict],
-    online_results: Optional[Dict[str, Dict]] = None,
-    code_results: Optional[Dict[str, Dict]] = None,
-    operator_results: Optional[List[OperatorRun]] = None,
-    query_images: Optional[list[str]] = None,
-    query_files: str = None,
-    generated_files: List[FileAttachment] = None,
-    generated_asset_results: Dict[str, Dict] = {},
-    program_execution_context: List[str] = None,
-    location_data: LocationData = None,
-    user_name: str = None,
-    chat_history: List[ChatMessageModel] = [],
+    messages: List[ChatMessage],
     # Model
-    model: Optional[str] = "gemini-2.0-flash",
+    model: Optional[str] = "gemini-2.5-flash",
     api_key: Optional[str] = None,
     api_base_url: Optional[str] = None,
     temperature: float = 1.0,
-    max_prompt_size=None,
-    tokenizer_name=None,
-    agent: Agent = None,
-    vision_available: bool = False,
     deepthought: Optional[bool] = False,
     tracer={},
 ) -> AsyncGenerator[ResponseWithThought, None]:
     """
     Converse with user using Google's Gemini
     """
-    # Initialize Variables
-    current_date = datetime.now()
-
-    if agent and agent.personality:
-        system_prompt = prompts.custom_personality.format(
-            name=agent.name,
-            bio=agent.personality,
-            current_date=current_date.strftime("%Y-%m-%d"),
-            day_of_week=current_date.strftime("%A"),
-        )
-    else:
-        system_prompt = prompts.personality.format(
-            current_date=current_date.strftime("%Y-%m-%d"),
-            day_of_week=current_date.strftime("%A"),
-        )
-
-    system_prompt += f"{system_prompt}\n\n{prompts.gemini_verbose_language_personality}"
-    if location_data:
-        location_prompt = prompts.user_location.format(location=f"{location_data}")
-        system_prompt = f"{system_prompt}\n{location_prompt}"
-
-    if user_name:
-        user_name_prompt = prompts.user_name.format(name=user_name)
-        system_prompt = f"{system_prompt}\n{user_name_prompt}"
-
-    context_message = ""
-    if not is_none_or_empty(references):
-        context_message = f"{prompts.notes_conversation.format(query=user_query, references=yaml_dump(references))}\n\n"
-    if not is_none_or_empty(online_results):
-        context_message += f"{prompts.online_search_conversation.format(online_results=yaml_dump(online_results))}\n\n"
-    if not is_none_or_empty(code_results):
-        context_message += (
-            f"{prompts.code_executed_context.format(code_results=truncate_code_context(code_results))}\n\n"
-        )
-    if not is_none_or_empty(operator_results):
-        operator_content = [
-            {"query": oc.query, "response": oc.response, "webpages": oc.webpages} for oc in operator_results
-        ]
-        context_message += (
-            f"{prompts.operator_execution_context.format(operator_results=yaml_dump(operator_content))}\n\n"
-        )
-    context_message = context_message.strip()
-
-    # Setup Prompt with Primer or Conversation History
-    messages = generate_chatml_messages_with_context(
-        user_query,
-        context_message=context_message,
-        chat_history=chat_history,
-        model_name=model,
-        max_prompt_size=max_prompt_size,
-        tokenizer_name=tokenizer_name,
-        query_images=query_images,
-        vision_enabled=vision_available,
-        model_type=ChatModel.ModelType.GOOGLE,
-        query_files=query_files,
-        generated_files=generated_files,
-        generated_asset_results=generated_asset_results,
-        program_execution_context=program_execution_context,
-    )
-
     logger.debug(f"Conversation Context for Gemini: {messages_to_print(messages)}")
 
     # Get Response from Google AI
@@ -159,7 +76,6 @@ async def converse_gemini(
         temperature=temperature,
         api_key=api_key,
         api_base_url=api_base_url,
-        system_prompt=system_prompt,
         deepthought=deepthought,
         tracer=tracer,
     ):

khoj/processor/conversation/google/utils.py

@@ -46,7 +46,7 @@ gemini_clients: Dict[str, genai.Client] = {}
 # This avoids premature response termination.
 MAX_OUTPUT_TOKENS_FOR_REASONING_GEMINI = 20000
 MAX_OUTPUT_TOKENS_FOR_STANDARD_GEMINI = 8000
-MAX_REASONING_TOKENS_GEMINI = 10000
+MAX_REASONING_TOKENS_GEMINI = 512
 
 SAFETY_SETTINGS = [
     gtypes.SafetySetting(
@@ -120,11 +120,7 @@ def _is_retryable_error(exception: BaseException) -> bool:
     if isinstance(exception, (gerrors.APIError, gerrors.ClientError, GeminiRetryableClientError)):
         return exception.code in [429, 502, 503, 504]
     # client errors
-    if (
-        isinstance(exception, httpx.TimeoutException)
-        or isinstance(exception, httpx.NetworkError)
-        or isinstance(exception, httpx.ReadError)
-    ):
+    if isinstance(exception, httpx.TimeoutException) or isinstance(exception, httpx.NetworkError):
         return True
     # validation errors
     if isinstance(exception, ValueError):
@@ -312,7 +308,7 @@ async def gemini_chat_completion_with_backoff(
     temperature: float,
     api_key: str,
     api_base_url: str,
-    system_prompt: str,
+    system_prompt: str = "",
     model_kwargs=None,
     deepthought=False,
     tracer: dict = {},
@@ -476,9 +472,12 @@ def format_messages_for_gemini(
     for message in messages.copy():
         if message.role == "system":
             if isinstance(message.content, list):
-                system_prompt += "\n".join([part["text"] for part in message.content if part["type"] == "text"])
+                system_prompt += "\n\n" + "\n".join(
+                    [part["text"] for part in message.content if part["type"] == "text"]
+                )
             else:
-                system_prompt += message.content
+                system_prompt += "\n\n" + message.content
+            system_prompt = system_prompt.strip()
             messages.remove(message)
     system_prompt = None if is_none_or_empty(system_prompt) else system_prompt
 

khoj/processor/conversation/openai/gpt.py

@@ -1,29 +1,25 @@
 import logging
-from datetime import datetime
 from typing import Any, AsyncGenerator, Dict, List, Optional
 
-from khoj.database.models import Agent, ChatMessageModel, ChatModel
-from khoj.processor.conversation import prompts
+from langchain_core.messages.chat import ChatMessage
+
 from khoj.processor.conversation.openai.utils import (
     chat_completion_with_backoff,
     clean_response_schema,
     completion_with_backoff,
     get_structured_output_support,
-    is_openai_api,
+    is_cerebras_api,
     responses_chat_completion_with_backoff,
     responses_completion_with_backoff,
+    supports_responses_api,
     to_openai_tools,
 )
 from khoj.processor.conversation.utils import (
-    OperatorRun,
     ResponseWithThought,
     StructuredOutputSupport,
-    generate_chatml_messages_with_context,
     messages_to_print,
 )
-from khoj.utils.helpers import ToolDefinition, is_none_or_empty, truncate_code_context
-from khoj.utils.rawconfig import FileAttachment, LocationData
-from khoj.utils.yaml import yaml_dump
+from khoj.utils.helpers import ToolDefinition
 
 logger = logging.getLogger(__name__)
 
@@ -45,16 +41,19 @@ def send_message_to_model(
 
     model_kwargs: Dict[str, Any] = {}
     json_support = get_structured_output_support(model, api_base_url)
+    strict = not is_cerebras_api(api_base_url)
     if tools and json_support == StructuredOutputSupport.TOOL:
-        model_kwargs["tools"] = to_openai_tools(tools, use_responses_api=is_openai_api(api_base_url))
+        model_kwargs["tools"] = to_openai_tools(
+            tools, use_responses_api=supports_responses_api(model, api_base_url), strict=strict
+        )
     elif response_schema and json_support >= StructuredOutputSupport.SCHEMA:
         # Drop unsupported fields from schema passed to OpenAI APi
         cleaned_response_schema = clean_response_schema(response_schema)
-        if is_openai_api(api_base_url):
+        if supports_responses_api(model, api_base_url):
             model_kwargs["text"] = {
                 "format": {
                     "type": "json_schema",
-                    "strict": True,
+                    "strict": strict,
                     "name": response_schema.__name__,
                     "schema": cleaned_response_schema,
                 }
@@ -65,14 +64,14 @@ def send_message_to_model(
                 "json_schema": {
                     "schema": cleaned_response_schema,
                     "name": response_schema.__name__,
-                    "strict": True,
+                    "strict": strict,
                 },
             }
     elif response_type == "json_object" and json_support == StructuredOutputSupport.OBJECT:
         model_kwargs["response_format"] = {"type": response_type}
 
     # Get Response from GPT
-    if is_openai_api(api_base_url):
+    if supports_responses_api(model, api_base_url):
         return responses_completion_with_backoff(
             messages=messages,
             model_name=model,
@@ -96,98 +95,22 @@ def send_message_to_model(
 
 async def converse_openai(
     # Query
-    user_query: str,
-    # Context
-    references: list[dict],
-    online_results: Optional[Dict[str, Dict]] = None,
-    code_results: Optional[Dict[str, Dict]] = None,
-    operator_results: Optional[List[OperatorRun]] = None,
-    query_images: Optional[list[str]] = None,
-    query_files: str = None,
-    generated_files: List[FileAttachment] = None,
-    generated_asset_results: Dict[str, Dict] = {},
-    program_execution_context: List[str] = None,
-    location_data: LocationData = None,
-    chat_history: list[ChatMessageModel] = [],
+    messages: List[ChatMessage],
+    # Model
     model: str = "gpt-4.1-mini",
     api_key: Optional[str] = None,
     api_base_url: Optional[str] = None,
     temperature: float = 0.6,
-    max_prompt_size=None,
-    tokenizer_name=None,
-    user_name: str = None,
-    agent: Agent = None,
-    vision_available: bool = False,
     deepthought: Optional[bool] = False,
     tracer: dict = {},
 ) -> AsyncGenerator[ResponseWithThought, None]:
     """
     Converse with user using OpenAI's ChatGPT
     """
-    # Initialize Variables
-    current_date = datetime.now()
-
-    if agent and agent.personality:
-        system_prompt = prompts.custom_personality.format(
-            name=agent.name,
-            bio=agent.personality,
-            current_date=current_date.strftime("%Y-%m-%d"),
-            day_of_week=current_date.strftime("%A"),
-        )
-    else:
-        system_prompt = prompts.personality.format(
-            current_date=current_date.strftime("%Y-%m-%d"),
-            day_of_week=current_date.strftime("%A"),
-        )
-
-    if location_data:
-        location_prompt = prompts.user_location.format(location=f"{location_data}")
-        system_prompt = f"{system_prompt}\n{location_prompt}"
-
-    if user_name:
-        user_name_prompt = prompts.user_name.format(name=user_name)
-        system_prompt = f"{system_prompt}\n{user_name_prompt}"
-
-    context_message = ""
-    if not is_none_or_empty(references):
-        context_message = f"{prompts.notes_conversation.format(references=yaml_dump(references))}\n\n"
-    if not is_none_or_empty(online_results):
-        context_message += f"{prompts.online_search_conversation.format(online_results=yaml_dump(online_results))}\n\n"
-    if not is_none_or_empty(code_results):
-        context_message += (
-            f"{prompts.code_executed_context.format(code_results=truncate_code_context(code_results))}\n\n"
-        )
-    if not is_none_or_empty(operator_results):
-        operator_content = [
-            {"query": oc.query, "response": oc.response, "webpages": oc.webpages} for oc in operator_results
-        ]
-        context_message += (
-            f"{prompts.operator_execution_context.format(operator_results=yaml_dump(operator_content))}\n\n"
-        )
-
-    context_message = context_message.strip()
-
-    # Setup Prompt with Primer or Conversation History
-    messages = generate_chatml_messages_with_context(
-        user_query,
-        system_prompt,
-        chat_history,
-        context_message=context_message,
-        model_name=model,
-        max_prompt_size=max_prompt_size,
-        tokenizer_name=tokenizer_name,
-        query_images=query_images,
-        vision_enabled=vision_available,
-        model_type=ChatModel.ModelType.OPENAI,
-        query_files=query_files,
-        generated_files=generated_files,
-        generated_asset_results=generated_asset_results,
-        program_execution_context=program_execution_context,
-    )
     logger.debug(f"Conversation Context for GPT: {messages_to_print(messages)}")
 
     # Get Response from GPT
-    if is_openai_api(api_base_url):
+    if supports_responses_api(model, api_base_url):
         async for chunk in responses_chat_completion_with_backoff(
             messages=messages,
             model_name=model,

khoj/processor/conversation/openai/utils.py

@@ -111,14 +111,16 @@ def completion_with_backoff(
     model_kwargs["temperature"] = temperature
     model_kwargs["top_p"] = model_kwargs.get("top_p", 0.95)
 
-    formatted_messages = format_message_for_api(messages, api_base_url)
+    formatted_messages = format_message_for_api(messages, model_name, api_base_url)
 
     # Tune reasoning models arguments
     if is_openai_reasoning_model(model_name, api_base_url):
         model_kwargs["temperature"] = 1
         reasoning_effort = "medium" if deepthought else "low"
         model_kwargs["reasoning_effort"] = reasoning_effort
+        # Remove unsupported params for reasoning models
         model_kwargs.pop("top_p", None)
+        model_kwargs.pop("stop", None)
     elif is_twitter_reasoning_model(model_name, api_base_url):
         model_kwargs.pop("temperature", None)
         reasoning_effort = "high" if deepthought else "low"
@@ -126,7 +128,7 @@ def completion_with_backoff(
         if model_name.startswith("grok-4"):
             # Grok-4 models do not support reasoning_effort parameter
             model_kwargs.pop("reasoning_effort", None)
-    elif model_name.startswith("deepseek-reasoner"):
+    elif model_name.startswith("deepseek-reasoner") or model_name.startswith("deepseek-chat"):
         stream_processor = in_stream_thought_processor
         # Two successive messages cannot be from the same role. Should merge any back-to-back messages from the same role.
         # The first message should always be a user message (except system message).
@@ -145,11 +147,8 @@ def completion_with_backoff(
         # See https://qwenlm.github.io/blog/qwen3/#advanced-usages
         if not deepthought:
             add_qwen_no_think_tag(formatted_messages)
-    elif "gpt-oss" in model_name.lower():
-        model_kwargs["temperature"] = 1
-        reasoning_effort = "medium" if deepthought else "low"
-        model_kwargs["reasoning_effort"] = reasoning_effort
-        model_kwargs["top_p"] = 1.0
+    elif is_groq_api(api_base_url):
+        model_kwargs["service_tier"] = "auto"
 
     read_timeout = 300 if is_local_api(api_base_url) else 60
     if os.getenv("KHOJ_LLM_SEED"):
@@ -297,7 +296,7 @@ async def chat_completion_with_backoff(
 
     model_kwargs["top_p"] = model_kwargs.get("top_p", 0.95)
 
-    formatted_messages = format_message_for_api(messages, api_base_url)
+    formatted_messages = format_message_for_api(messages, model_name, api_base_url)
 
     # Configure thinking for openai reasoning models
     if is_openai_reasoning_model(model_name, api_base_url):
@@ -307,26 +306,17 @@ async def chat_completion_with_backoff(
         # Remove unsupported params for reasoning models
         model_kwargs.pop("top_p", None)
         model_kwargs.pop("stop", None)
-
-        # Get the first system message and add the string `Formatting re-enabled` to it.
-        # See https://platform.openai.com/docs/guides/reasoning-best-practices
-        if len(formatted_messages) > 0:
-            system_messages = [
-                (i, message) for i, message in enumerate(formatted_messages) if message["role"] == "system"
-            ]
-            if len(system_messages) > 0:
-                first_system_message_index, first_system_message = system_messages[0]
-                first_system_message_content = first_system_message["content"]
-                formatted_messages[first_system_message_index]["content"] = (
-                    f"{first_system_message_content}\nFormatting re-enabled"
-                )
     elif is_twitter_reasoning_model(model_name, api_base_url):
         reasoning_effort = "high" if deepthought else "low"
         # Grok-4 models do not support reasoning_effort parameter
         if not model_name.startswith("grok-4"):
             model_kwargs["reasoning_effort"] = reasoning_effort
-    elif model_name.startswith("deepseek-reasoner") or "deepseek-r1" in model_name:
-        # Official Deepseek reasoner model and some inference APIs like vLLM return structured thinking output.
+    elif (
+        model_name.startswith("deepseek-chat")
+        or model_name.startswith("deepseek-reasoner")
+        or "deepseek-r1" in model_name.lower()
+    ):
+        # Official Deepseek models and some inference APIs like vLLM return structured thinking output.
         # Others like DeepInfra return it in response stream.
         # Using the instream thought processor handles both cases, structured thoughts and in response thoughts.
         stream_processor = ain_stream_thought_processor
@@ -351,11 +341,8 @@ async def chat_completion_with_backoff(
         # See https://qwenlm.github.io/blog/qwen3/#advanced-usages
         if not deepthought:
             add_qwen_no_think_tag(formatted_messages)
-    elif "gpt-oss" in model_name.lower():
-        temperature = 1
-        reasoning_effort = "medium" if deepthought else "low"
-        model_kwargs["reasoning_effort"] = reasoning_effort
-        model_kwargs["top_p"] = 1.0
+    elif is_groq_api(api_base_url):
+        model_kwargs["service_tier"] = "auto"
 
     read_timeout = 300 if is_local_api(api_base_url) else 60
     if os.getenv("KHOJ_LLM_SEED"):
@@ -461,7 +448,7 @@ def responses_completion_with_backoff(
         client = get_openai_client(openai_api_key, api_base_url)
         openai_clients[client_key] = client
 
-    formatted_messages = format_message_for_api(messages, api_base_url)
+    formatted_messages = format_message_for_api(messages, model_name, api_base_url)
     # Move the first system message to Responses API instructions
     instructions: Optional[str] = None
     if formatted_messages and formatted_messages[0].get("role") == "system":
@@ -474,8 +461,10 @@ def responses_completion_with_backoff(
     if is_openai_reasoning_model(model_name, api_base_url):
         temperature = 1
         reasoning_effort = "medium" if deepthought else "low"
-        model_kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
-        model_kwargs["include"] = ["reasoning.encrypted_content"]
+        model_kwargs["reasoning"] = {"effort": reasoning_effort}
+        if is_openai_api(api_base_url):
+            model_kwargs["reasoning"]["summary"] = "auto"
+            model_kwargs["include"] = ["reasoning.encrypted_content"]
         # Remove unsupported params for reasoning models
         model_kwargs.pop("top_p", None)
         model_kwargs.pop("stop", None)
@@ -572,7 +561,7 @@ async def responses_chat_completion_with_backoff(
         client = get_openai_async_client(openai_api_key, api_base_url)
         openai_async_clients[client_key] = client
 
-    formatted_messages = format_message_for_api(messages, api_base_url)
+    formatted_messages = format_message_for_api(messages, model_name, api_base_url)
     # Move the first system message to Responses API instructions
     instructions: Optional[str] = None
     if formatted_messages and formatted_messages[0].get("role") == "system":
@@ -585,7 +574,10 @@ async def responses_chat_completion_with_backoff(
     if is_openai_reasoning_model(model_name, api_base_url):
         temperature = 1
         reasoning_effort = "medium" if deepthought else "low"
-        model_kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        model_kwargs["reasoning"] = {"effort": reasoning_effort}
+        if is_openai_api(api_base_url):
+            model_kwargs["reasoning"]["summary"] = "auto"
+            model_kwargs["include"] = ["reasoning.encrypted_content"]
         # Remove unsupported params for reasoning models
         model_kwargs.pop("top_p", None)
         model_kwargs.pop("stop", None)
@@ -718,7 +710,7 @@ def get_structured_output_support(model_name: str, api_base_url: str = None) ->
     return StructuredOutputSupport.TOOL
 
 
-def format_message_for_api(raw_messages: List[ChatMessage], api_base_url: str) -> List[dict]:
+def format_message_for_api(raw_messages: List[ChatMessage], model_name: str, api_base_url: str) -> List[dict]:
     """
     Format messages to send to chat model served over OpenAI (compatible) API.
     """
@@ -728,7 +720,7 @@ def format_message_for_api(raw_messages: List[ChatMessage], api_base_url: str) -
         # Handle tool call and tool result message types
         message_type = message.additional_kwargs.get("message_type")
         if message_type == "tool_call":
-            if is_openai_api(api_base_url):
+            if supports_responses_api(model_name, api_base_url):
                 for part in message.content:
                     if "status" in part:
                         part.pop("status")  # Drop unsupported tool call status field
@@ -772,7 +764,7 @@ def format_message_for_api(raw_messages: List[ChatMessage], api_base_url: str) -
                 if not tool_call_id:
                     logger.warning(f"Dropping tool result without valid tool_call_id: {part.get('name')}")
                     continue
-                if is_openai_api(api_base_url):
+                if supports_responses_api(model_name, api_base_url):
                     formatted_messages.append(
                         {
                             "type": "function_call_output",
@@ -790,7 +782,7 @@ def format_message_for_api(raw_messages: List[ChatMessage], api_base_url: str) -
                         }
                     )
             continue
-        if isinstance(message.content, list) and not is_openai_api(api_base_url):
+        if isinstance(message.content, list) and not supports_responses_api(model_name, api_base_url):
             assistant_texts = []
             has_images = False
             for idx, part in enumerate(message.content):
@@ -803,7 +795,7 @@ def format_message_for_api(raw_messages: List[ChatMessage], api_base_url: str) -
                 if (
                     part.get("type") == "text"
                     and message.role == "assistant"
-                    and api_base_url.startswith("https://api.deepinfra.com/v1")
+                    and (api_base_url.startswith("https://api.deepinfra.com/v1") or is_cerebras_api(api_base_url))
                 ):
                     assistant_texts += [part["text"]]
                     message.content.pop(idx)
@@ -846,12 +838,21 @@ def is_openai_api(api_base_url: str = None) -> bool:
     return api_base_url is None or api_base_url.startswith("https://api.openai.com/v1")
 
 
+def supports_responses_api(model_name: str, api_base_url: str = None) -> bool:
+    """
+    Check if the model, ai api supports the OpenAI Responses API
+    """
+    return is_openai_api(api_base_url)
+
+
 def is_openai_reasoning_model(model_name: str, api_base_url: str = None) -> bool:
     """
     Check if the model is an OpenAI reasoning model
     """
-    return is_openai_api(api_base_url) and (
-        model_name.lower().startswith("o") or model_name.lower().startswith("gpt-5")
+    return (
+        is_openai_api(api_base_url)
+        and (model_name.lower().startswith("o") or model_name.lower().startswith("gpt-5"))
+        or "gpt-oss" in model_name.lower()
     )
 
 
@@ -875,6 +876,20 @@ def is_twitter_reasoning_model(model_name: str, api_base_url: str = None) -> boo
     )
 
 
+def is_cerebras_api(api_base_url: str = None) -> bool:
+    """
+    Check if the model is served over the Cerebras API
+    """
+    return api_base_url is not None and api_base_url.startswith("https://api.cerebras.ai/v1")
+
+
+def is_groq_api(api_base_url: str = None) -> bool:
+    """
+    Check if the model is served over the Groq API
+    """
+    return api_base_url is not None and api_base_url.startswith("https://api.groq.com")
+
+
 def is_qwen_style_reasoning_model(model_name: str, api_base_url: str = None) -> bool:
     """
     Check if the model is a Qwen style reasoning model
@@ -1204,7 +1219,7 @@ def add_qwen_no_think_tag(formatted_messages: List[dict]) -> None:
                         break
 
 
-def to_openai_tools(tools: List[ToolDefinition], use_responses_api: bool) -> List[Dict] | None:
+def to_openai_tools(tools: List[ToolDefinition], use_responses_api: bool, strict: bool) -> List[Dict] | None:
     "Transform tool definitions from standard format to OpenAI format."
     if use_responses_api:
         openai_tools = [
@@ -1213,7 +1228,7 @@ def to_openai_tools(tools: List[ToolDefinition], use_responses_api: bool) -> Lis
                 "name": tool.name,
                 "description": tool.description,
                 "parameters": clean_response_schema(tool.schema),
-                "strict": True,
+                "strict": strict,
             }
             for tool in tools
         ]
@@ -1225,7 +1240,7 @@ def to_openai_tools(tools: List[ToolDefinition], use_responses_api: bool) -> Lis
                     "name": tool.name,
                     "description": tool.description,
                     "parameters": clean_response_schema(tool.schema),
-                    "strict": True,
+                    "strict": strict,
                 },
             }
             for tool in tools