khoj 2.0.0b13.dev19__py3-none-any.whl → 2.0.0b14__py3-none-any.whl

khoj/processor/conversation/openai/utils.py

@@ -21,6 +21,8 @@ from openai.types.chat.chat_completion_chunk import (
     Choice,
     ChoiceDelta,
 )
+from openai.types.responses import Response as OpenAIResponse
+from openai.types.responses import ResponseFunctionToolCall, ResponseReasoningItem
 from pydantic import BaseModel
 from tenacity import (
     before_sleep_log,
@@ -53,13 +55,31 @@ openai_clients: Dict[str, openai.OpenAI] = {}
 openai_async_clients: Dict[str, openai.AsyncOpenAI] = {}
 
 
+def _extract_text_for_instructions(content: Union[str, List, Dict, None]) -> str:
+    """Extract plain text from a message content suitable for Responses API instructions."""
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        texts: List[str] = []
+        for part in content:
+            if isinstance(part, dict) and part.get("type") == "input_text" and part.get("text"):
+                texts.append(str(part.get("text")))
+        return "\n\n".join(texts)
+    if isinstance(content, dict):
+        # If a single part dict was passed
+        if content.get("type") == "input_text" and content.get("text"):
+            return str(content.get("text"))
+    # Fallback to string conversion
+    return str(content)
+
+
 @retry(
     retry=(
         retry_if_exception_type(openai._exceptions.APITimeoutError)
-        | retry_if_exception_type(openai._exceptions.APIError)
-        | retry_if_exception_type(openai._exceptions.APIConnectionError)
         | retry_if_exception_type(openai._exceptions.RateLimitError)
-        | retry_if_exception_type(openai._exceptions.APIStatusError)
+        | retry_if_exception_type(openai._exceptions.InternalServerError)
         | retry_if_exception_type(ValueError)
     ),
     wait=wait_random_exponential(min=1, max=10),
@@ -106,7 +126,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).
@@ -125,6 +145,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 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"):
@@ -150,8 +172,16 @@ def completion_with_backoff(
                     chunk.type == "chunk"
                     and chunk.chunk.choices
                     and hasattr(chunk.chunk.choices[0].delta, "reasoning_content")
+                    and chunk.chunk.choices[0].delta.reasoning_content
                 ):
                     thoughts += chunk.chunk.choices[0].delta.reasoning_content
+                elif (
+                    chunk.type == "chunk"
+                    and chunk.chunk.choices
+                    and hasattr(chunk.chunk.choices[0].delta, "reasoning")
+                    and chunk.chunk.choices[0].delta.reasoning
+                ):
+                    thoughts += chunk.chunk.choices[0].delta.reasoning
                 elif chunk.type == "chunk" and chunk.chunk.choices and chunk.chunk.choices[0].delta.tool_calls:
                     tool_ids += [tool_call.id for tool_call in chunk.chunk.choices[0].delta.tool_calls]
                 elif chunk.type == "tool_calls.function.arguments.done":
@@ -174,7 +204,6 @@ def completion_with_backoff(
         chunk = client.beta.chat.completions.parse(
             messages=formatted_messages,  # type: ignore
             model=model_name,
-            temperature=temperature,
             timeout=httpx.Timeout(30, read=read_timeout),
             **model_kwargs,
         )
@@ -199,6 +228,10 @@ def completion_with_backoff(
             # Json dump tool calls into aggregated response
             aggregated_response = json.dumps([tool_call.__dict__ for tool_call in tool_calls])
 
+    # Align chunk definition with non-streaming mode for post stream completion usage
+    if hasattr(chunk, "chunk"):
+        chunk = chunk.chunk
+
     # Calculate cost of chat
     input_tokens = chunk.usage.prompt_tokens if hasattr(chunk, "usage") and chunk.usage else 0
     output_tokens = chunk.usage.completion_tokens if hasattr(chunk, "usage") and chunk.usage else 0
@@ -227,10 +260,8 @@ def completion_with_backoff(
 @retry(
     retry=(
         retry_if_exception_type(openai._exceptions.APITimeoutError)
-        | retry_if_exception_type(openai._exceptions.APIError)
-        | retry_if_exception_type(openai._exceptions.APIConnectionError)
         | retry_if_exception_type(openai._exceptions.RateLimitError)
-        | retry_if_exception_type(openai._exceptions.APIStatusError)
+        | retry_if_exception_type(openai._exceptions.InternalServerError)
         | retry_if_exception_type(ValueError)
     ),
     wait=wait_exponential(multiplier=1, min=4, max=10),
@@ -291,8 +322,12 @@ async def chat_completion_with_backoff(
         # 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
+    ):
+        # 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
@@ -317,6 +352,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 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"):
@@ -390,6 +427,283 @@ async def chat_completion_with_backoff(
         commit_conversation_trace(messages, aggregated_response, tracer)
 
 
+@retry(
+    retry=(
+        retry_if_exception_type(openai._exceptions.APITimeoutError)
+        | retry_if_exception_type(openai._exceptions.RateLimitError)
+        | retry_if_exception_type(openai._exceptions.InternalServerError)
+        | retry_if_exception_type(ValueError)
+    ),
+    wait=wait_random_exponential(min=1, max=10),
+    stop=stop_after_attempt(3),
+    before_sleep=before_sleep_log(logger, logging.DEBUG),
+    reraise=True,
+)
+def responses_completion_with_backoff(
+    messages: List[ChatMessage],
+    model_name: str,
+    temperature=0.6,
+    openai_api_key=None,
+    api_base_url=None,
+    deepthought: bool = False,
+    model_kwargs: dict = {},
+    tracer: dict = {},
+) -> ResponseWithThought:
+    """
+    Synchronous helper using the OpenAI Responses API in streaming mode under the hood.
+    Aggregates streamed deltas and returns a ResponseWithThought.
+    """
+    client_key = f"{openai_api_key}--{api_base_url}"
+    client = openai_clients.get(client_key)
+    if not client:
+        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)
+    # Move the first system message to Responses API instructions
+    instructions: Optional[str] = None
+    if formatted_messages and formatted_messages[0].get("role") == "system":
+        instructions = _extract_text_for_instructions(formatted_messages[0].get("content")) or None
+        formatted_messages = formatted_messages[1:]
+
+    model_kwargs = deepcopy(model_kwargs)
+    model_kwargs["top_p"] = model_kwargs.get("top_p", 0.95)
+    # Configure thinking for openai reasoning models
+    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"]
+        # Remove unsupported params for reasoning models
+        model_kwargs.pop("top_p", None)
+        model_kwargs.pop("stop", None)
+
+    read_timeout = 300 if is_local_api(api_base_url) else 60
+
+    # Stream and aggregate
+    model_response: OpenAIResponse = client.responses.create(
+        input=formatted_messages,
+        instructions=instructions,
+        model=model_name,
+        temperature=temperature,
+        timeout=httpx.Timeout(30, read=read_timeout),  # type: ignore
+        store=False,
+        **model_kwargs,
+    )
+    if not model_response or not isinstance(model_response, OpenAIResponse) or not model_response.output:
+        raise ValueError(f"Empty response returned by {model_name}.")
+
+    raw_content = [item.model_dump() for item in model_response.output]
+    aggregated_text = model_response.output_text
+    thoughts = ""
+    tool_calls: List[ToolCall] = []
+    for item in model_response.output:
+        if isinstance(item, ResponseFunctionToolCall):
+            tool_calls.append(ToolCall(name=item.name, args=json.loads(item.arguments), id=item.call_id))
+        elif isinstance(item, ResponseReasoningItem):
+            thoughts = "\n\n".join([summary.text for summary in item.summary])
+
+    if tool_calls:
+        if thoughts and aggregated_text:
+            # If there are tool calls, aggregate thoughts and responses into thoughts
+            thoughts = "\n".join([f"*{line.strip()}*" for line in thoughts.splitlines() if line.strip()])
+            thoughts = f"{thoughts}\n\n{aggregated_text}"
+        else:
+            thoughts = thoughts or aggregated_text
+        # Json dump tool calls into aggregated response
+        aggregated_text = json.dumps([tool_call.__dict__ for tool_call in tool_calls])
+
+    # Usage/cost tracking
+    input_tokens = model_response.usage.input_tokens if model_response and model_response.usage else 0
+    output_tokens = model_response.usage.output_tokens if model_response and model_response.usage else 0
+    cost = 0
+    cache_read_tokens = 0
+    if model_response and model_response.usage and model_response.usage.input_tokens_details:
+        cache_read_tokens = model_response.usage.input_tokens_details.cached_tokens
+        input_tokens -= cache_read_tokens
+    tracer["usage"] = get_chat_usage_metrics(
+        model_name, input_tokens, output_tokens, cache_read_tokens, usage=tracer.get("usage"), cost=cost
+    )
+
+    # Validate final aggregated text (either message or tool-calls JSON)
+    if is_none_or_empty(aggregated_text):
+        logger.warning(f"No response by {model_name}\nLast Message by {messages[-1].role}: {messages[-1].content}.")
+        raise ValueError(f"Empty or no response by {model_name} over Responses API. Retry if needed.")
+
+    # Trace
+    tracer["chat_model"] = model_name
+    tracer["temperature"] = temperature
+    if is_promptrace_enabled():
+        commit_conversation_trace(messages, aggregated_text, tracer)
+
+    return ResponseWithThought(text=aggregated_text, thought=thoughts, raw_content=raw_content)
+
+
+@retry(
+    retry=(
+        retry_if_exception_type(openai._exceptions.APITimeoutError)
+        | retry_if_exception_type(openai._exceptions.RateLimitError)
+        | retry_if_exception_type(openai._exceptions.InternalServerError)
+        | retry_if_exception_type(ValueError)
+    ),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+    stop=stop_after_attempt(3),
+    before_sleep=before_sleep_log(logger, logging.WARNING),
+    reraise=False,
+)
+async def responses_chat_completion_with_backoff(
+    messages: list[ChatMessage],
+    model_name: str,
+    temperature,
+    openai_api_key=None,
+    api_base_url=None,
+    deepthought=False,  # Unused; parity with legacy signature
+    tracer: dict = {},
+) -> AsyncGenerator[ResponseWithThought, None]:
+    """
+    Async streaming helper using the OpenAI Responses API.
+    Yields ResponseWithThought chunks as text/think deltas arrive.
+    """
+    client_key = f"{openai_api_key}--{api_base_url}"
+    client = openai_async_clients.get(client_key)
+    if not client:
+        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)
+    # Move the first system message to Responses API instructions
+    instructions: Optional[str] = None
+    if formatted_messages and formatted_messages[0].get("role") == "system":
+        instructions = _extract_text_for_instructions(formatted_messages[0].get("content")) or None
+        formatted_messages = formatted_messages[1:]
+
+    model_kwargs: dict = {}
+    model_kwargs["top_p"] = model_kwargs.get("top_p", 0.95)
+    # Configure thinking for openai reasoning models
+    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"}
+        # Remove unsupported params for reasoning models
+        model_kwargs.pop("top_p", None)
+        model_kwargs.pop("stop", None)
+
+    read_timeout = 300 if is_local_api(api_base_url) else 60
+
+    aggregated_text = ""
+    last_final: Optional[OpenAIResponse] = None
+    # Tool call assembly buffers
+    tool_calls_args: Dict[str, str] = {}
+    tool_calls_name: Dict[str, str] = {}
+    tool_call_order: List[str] = []
+
+    async with client.responses.stream(
+        input=formatted_messages,
+        instructions=instructions,
+        model=model_name,
+        temperature=temperature,
+        timeout=httpx.Timeout(30, read=read_timeout),
+        **model_kwargs,
+    ) as stream:  # type: ignore
+        async for event in stream:  # type: ignore
+            et = getattr(event, "type", "")
+            if et == "response.output_text.delta":
+                delta = getattr(event, "delta", "") or getattr(event, "output_text", "")
+                if delta:
+                    aggregated_text += delta
+                    yield ResponseWithThought(text=delta)
+            elif et == "response.reasoning.delta":
+                delta = getattr(event, "delta", "")
+                if delta:
+                    yield ResponseWithThought(thought=delta)
+            elif et == "response.tool_call.created":
+                item = getattr(event, "item", None)
+                tool_id = (
+                    getattr(event, "id", None)
+                    or getattr(event, "tool_call_id", None)
+                    or (getattr(item, "id", None) if item is not None else None)
+                )
+                name = (
+                    getattr(event, "name", None)
+                    or (getattr(item, "name", None) if item is not None else None)
+                    or getattr(event, "tool_name", None)
+                )
+                if tool_id:
+                    if tool_id not in tool_calls_args:
+                        tool_calls_args[tool_id] = ""
+                        tool_call_order.append(tool_id)
+                    if name:
+                        tool_calls_name[tool_id] = name
+            elif et == "response.tool_call.delta":
+                tool_id = getattr(event, "id", None) or getattr(event, "tool_call_id", None)
+                delta = getattr(event, "delta", None)
+                if hasattr(delta, "arguments"):
+                    arg_delta = getattr(delta, "arguments", "")
+                else:
+                    arg_delta = delta if isinstance(delta, str) else getattr(event, "arguments", "")
+                if tool_id and arg_delta:
+                    tool_calls_args[tool_id] = tool_calls_args.get(tool_id, "") + arg_delta
+                    if tool_id not in tool_call_order:
+                        tool_call_order.append(tool_id)
+            elif et == "response.tool_call.completed":
+                item = getattr(event, "item", None)
+                tool_id = (
+                    getattr(event, "id", None)
+                    or getattr(event, "tool_call_id", None)
+                    or (getattr(item, "id", None) if item is not None else None)
+                )
+                args_final = None
+                if item is not None:
+                    args_final = getattr(item, "arguments", None) or getattr(item, "args", None)
+                if tool_id and args_final:
+                    tool_calls_args[tool_id] = args_final if isinstance(args_final, str) else json.dumps(args_final)
+                    if tool_id not in tool_call_order:
+                        tool_call_order.append(tool_id)
+            # ignore other events for now
+        last_final = await stream.get_final_response()
+
+    # Usage/cost tracking after stream ends
+    input_tokens = last_final.usage.input_tokens if last_final and last_final.usage else 0
+    output_tokens = last_final.usage.output_tokens if last_final and last_final.usage else 0
+    cost = 0
+    tracer["usage"] = get_chat_usage_metrics(
+        model_name, input_tokens, output_tokens, usage=tracer.get("usage"), cost=cost
+    )
+
+    # If there are tool calls, package them into aggregated text for tracing parity
+    if tool_call_order:
+        packaged_tool_calls: List[ToolCall] = []
+        for tool_id in tool_call_order:
+            name = tool_calls_name.get(tool_id) or ""
+            args_str = tool_calls_args.get(tool_id, "")
+            try:
+                args = json.loads(args_str) if isinstance(args_str, str) else args_str
+            except Exception:
+                logger.warning(f"Failed to parse tool call arguments for {tool_id}: {args_str}")
+                args = {}
+            packaged_tool_calls.append(ToolCall(name=name, args=args, id=tool_id))
+        # Move any text into trace thought
+        tracer_text = aggregated_text
+        aggregated_text = json.dumps([tc.__dict__ for tc in packaged_tool_calls])
+        # Save for trace below
+        if tracer_text:
+            tracer.setdefault("_responses_stream_text", tracer_text)
+
+    if is_none_or_empty(aggregated_text):
+        logger.warning(f"No response by {model_name}\nLast Message by {messages[-1].role}: {messages[-1].content}.")
+        raise ValueError(f"Empty or no response by {model_name} over Responses API. Retry if needed.")
+
+    tracer["chat_model"] = model_name
+    tracer["temperature"] = temperature
+    if is_promptrace_enabled():
+        # If tool-calls were present, include any streamed text in the trace thought
+        trace_payload = aggregated_text
+        if tracer.get("_responses_stream_text"):
+            thoughts = tracer.pop("_responses_stream_text")
+            trace_payload = thoughts
+        commit_conversation_trace(messages, trace_payload, tracer)
+
+
 def get_structured_output_support(model_name: str, api_base_url: str = None) -> StructuredOutputSupport:
     if model_name.startswith("deepseek-reasoner"):
         return StructuredOutputSupport.NONE
@@ -412,6 +726,12 @@ 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):
+                for part in message.content:
+                    if "status" in part:
+                        part.pop("status")  # Drop unsupported tool call status field
+                formatted_messages.extend(message.content)
+                continue
             # Convert tool_call to OpenAI function call format
             content = []
             for part in message.content:
@@ -450,14 +770,23 @@ 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
-                formatted_messages.append(
-                    {
-                        "role": "tool",
-                        "tool_call_id": tool_call_id,
-                        "name": part.get("name"),
-                        "content": part.get("content"),
-                    }
-                )
+                if is_openai_api(api_base_url):
+                    formatted_messages.append(
+                        {
+                            "type": "function_call_output",
+                            "call_id": tool_call_id,
+                            "output": part.get("content") or "No output",
+                        }
+                    )
+                else:
+                    formatted_messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_call_id,
+                            "name": part.get("name"),
+                            "content": part.get("content") or "No output",
+                        }
+                    )
             continue
         if isinstance(message.content, list) and not is_openai_api(api_base_url):
             assistant_texts = []
@@ -489,6 +818,12 @@ def format_message_for_api(raw_messages: List[ChatMessage], api_base_url: str) -
                     message.content.remove(part)
                 elif part["type"] == "image_url" and not part.get("image_url"):
                     message.content.remove(part)
+                # OpenAI models use the Responses API which uses slightly different content types
+                if part["type"] == "text":
+                    part["type"] = "output_text" if message.role == "assistant" else "input_text"
+                if part["type"] == "image_url":
+                    part["type"] = "output_image" if message.role == "assistant" else "input_image"
+                    part["image_url"] = part["image_url"]["url"]
             # If no valid content parts left, remove the message
             if is_none_or_empty(message.content):
                 messages.remove(message)
@@ -513,7 +848,11 @@ def is_openai_reasoning_model(model_name: str, api_base_url: str = None) -> bool
     """
     Check if the model is an OpenAI reasoning model
     """
-    return model_name.lower().startswith("o") and is_openai_api(api_base_url)
+    return (
+        is_openai_api(api_base_url)
+        and (model_name.lower().startswith("o") or model_name.lower().startswith("gpt-5"))
+        or model_name.lower().startswith("gpt-oss")
+    )
 
 
 def is_non_streaming_model(model_name: str, api_base_url: str = None) -> bool:
@@ -536,6 +875,13 @@ def is_twitter_reasoning_model(model_name: str, api_base_url: str = None) -> boo
     )
 
 
+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
@@ -609,6 +955,9 @@ async def astream_thought_processor(
             if not chunk_data.get("object") or chunk_data.get("object") != "chat.completion.chunk":
                 logger.warning(f"Skipping invalid chunk with object field: {chunk_data.get('object', 'missing')}")
                 continue
+            # Handle unsupported service tiers like "on_demand" by Groq
+            if chunk.service_tier and chunk.service_tier == "on_demand":
+                chunk_data["service_tier"] = "auto"
 
             tchunk = ChatCompletionWithThoughtsChunk.model_validate(chunk_data)
 
@@ -620,6 +969,14 @@ async def astream_thought_processor(
             ):
                 tchunk.choices[0].delta.thought = chunk.choices[0].delta.reasoning_content
 
+            # Handlle openai reasoning style response with thoughts. Used by gpt-oss.
+            if (
+                len(tchunk.choices) > 0
+                and hasattr(tchunk.choices[0].delta, "reasoning")
+                and tchunk.choices[0].delta.reasoning
+            ):
+                tchunk.choices[0].delta.thought = chunk.choices[0].delta.reasoning
+
             # Handlle llama.cpp server style response with thoughts.
             elif len(tchunk.choices) > 0 and tchunk.choices[0].delta.model_extra.get("reasoning_content"):
                 tchunk.choices[0].delta.thought = tchunk.choices[0].delta.model_extra.get("reasoning_content")
@@ -750,6 +1107,10 @@ async def ain_stream_thought_processor(
             yield chunk
             continue
 
+        if chunk.choices[0].delta.content is None:
+            # If delta content is None, we can't process it, just yield the chunk
+            continue
+
         buf += chunk.choices[0].delta.content
 
         if mode == "detect_start":
@@ -850,20 +1211,32 @@ def add_qwen_no_think_tag(formatted_messages: List[dict]) -> None:
                         break
 
 
-def to_openai_tools(tools: List[ToolDefinition]) -> List[Dict] | None:
+def to_openai_tools(tools: List[ToolDefinition], use_responses_api: bool) -> List[Dict] | None:
     "Transform tool definitions from standard format to OpenAI format."
-    openai_tools = [
-        {
-            "type": "function",
-            "function": {
+    if use_responses_api:
+        openai_tools = [
+            {
+                "type": "function",
                 "name": tool.name,
                 "description": tool.description,
                 "parameters": clean_response_schema(tool.schema),
                 "strict": True,
-            },
-        }
-        for tool in tools
-    ]
+            }
+            for tool in tools
+        ]
+    else:
+        openai_tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": clean_response_schema(tool.schema),
+                    "strict": True,
+                },
+            }
+            for tool in tools
+        ]
 
     return openai_tools or None