letta-nightly 0.12.1.dev20251023104211__py3-none-any.whl → 0.13.0.dev20251024223017__py3-none-any.whl

letta/interfaces/openai_streaming_interface.py

@@ -43,6 +43,7 @@ from letta.schemas.letta_message import (
 )
 from letta.schemas.letta_message_content import (
     OmittedReasoningContent,
+    ReasoningContent,
     SummarizedReasoningContent,
     SummarizedReasoningContentPart,
     TextContent,
@@ -51,6 +52,7 @@ from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
 from letta.server.rest_api.json_parser import OptimisticJSONParser
+from letta.server.rest_api.utils import decrement_message_uuid
 from letta.streaming_utils import (
     FunctionArgumentsStreamHandler,
     JSONInnerThoughtsExtractor,
@@ -203,7 +205,7 @@ class OpenAIStreamingInterface:
         except Exception as e:
             import traceback
 
-            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            logger.exception("Error processing stream: %s", e)
             if ttft_span:
                 ttft_span.add_event(
                     name="stop_reason",
@@ -324,14 +326,14 @@ class OpenAIStreamingInterface:
                                 self.tool_call_name = str(self.function_name_buffer)
                                 if self.tool_call_name in self.requires_approval_tools:
                                     tool_call_msg = ApprovalRequestMessage(
-                                        id=self.letta_message_id,
+                                        id=decrement_message_uuid(self.letta_message_id),
                                         date=datetime.now(timezone.utc),
                                         tool_call=ToolCallDelta(
                                             name=self.function_name_buffer,
                                             arguments=None,
                                             tool_call_id=self.function_id_buffer,
                                         ),
-                                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                        otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                                         run_id=self.run_id,
                                         step_id=self.step_id,
                                     )
@@ -412,7 +414,7 @@ class OpenAIStreamingInterface:
                                         message_index += 1
                                     if self.function_name_buffer in self.requires_approval_tools:
                                         tool_call_msg = ApprovalRequestMessage(
-                                            id=self.letta_message_id,
+                                            id=decrement_message_uuid(self.letta_message_id),
                                             date=datetime.now(timezone.utc),
                                             tool_call=ToolCallDelta(
                                                 name=self.function_name_buffer,
@@ -420,7 +422,7 @@ class OpenAIStreamingInterface:
                                                 tool_call_id=self.function_id_buffer,
                                             ),
                                             # name=name,
-                                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                            otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                                             run_id=self.run_id,
                                             step_id=self.step_id,
                                         )
@@ -451,7 +453,7 @@ class OpenAIStreamingInterface:
                                         message_index += 1
                                     if self.function_name_buffer in self.requires_approval_tools:
                                         tool_call_msg = ApprovalRequestMessage(
-                                            id=self.letta_message_id,
+                                            id=decrement_message_uuid(self.letta_message_id),
                                             date=datetime.now(timezone.utc),
                                             tool_call=ToolCallDelta(
                                                 name=None,
@@ -459,7 +461,7 @@ class OpenAIStreamingInterface:
                                                 tool_call_id=self.function_id_buffer,
                                             ),
                                             # name=name,
-                                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                            otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                                             run_id=self.run_id,
                                             step_id=self.step_id,
                                         )
@@ -532,20 +534,31 @@ class SimpleOpenAIStreamingInterface:
 
         self.requires_approval_tools = requires_approval_tools
 
-    def get_content(self) -> list[TextContent | OmittedReasoningContent]:
+    def get_content(self) -> list[TextContent | OmittedReasoningContent | ReasoningContent]:
         shown_omitted = False
         concat_content = ""
         merged_messages = []
+        reasoning_content = []
+
         for msg in self.content_messages:
             if isinstance(msg, HiddenReasoningMessage) and not shown_omitted:
                 merged_messages.append(OmittedReasoningContent())
                 shown_omitted = True
+            elif isinstance(msg, ReasoningMessage):
+                reasoning_content.append(msg.reasoning)
             elif isinstance(msg, AssistantMessage):
                 if isinstance(msg.content, list):
                     concat_content += "".join([c.text for c in msg.content])
                 else:
                     concat_content += msg.content
-        merged_messages.append(TextContent(text=concat_content))
+
+        if reasoning_content:
+            combined_reasoning = "".join(reasoning_content)
+            merged_messages.append(ReasoningContent(is_native=True, reasoning=combined_reasoning, signature=None))
+
+        if concat_content:
+            merged_messages.append(TextContent(text=concat_content))
+
         return merged_messages
 
     def get_tool_call_object(self) -> ToolCall:
@@ -591,6 +604,8 @@ class SimpleOpenAIStreamingInterface:
                 # For reasoning models, emit a hidden reasoning message before the first chunk
                 if not self.emitted_hidden_reasoning and is_openai_reasoning_model(self.model):
                     self.emitted_hidden_reasoning = True
+                    if prev_message_type and prev_message_type != "hidden_reasoning_message":
+                        message_index += 1
                     hidden_message = HiddenReasoningMessage(
                         id=self.letta_message_id,
                         date=datetime.now(timezone.utc),
@@ -602,7 +617,6 @@ class SimpleOpenAIStreamingInterface:
                     )
                     self.content_messages.append(hidden_message)
                     prev_message_type = hidden_message.message_type
-                    message_index += 1  # Increment for the next message
                     yield hidden_message
 
                 async for chunk in stream:
@@ -632,7 +646,7 @@ class SimpleOpenAIStreamingInterface:
         except Exception as e:
             import traceback
 
-            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            logger.exception("Error processing stream: %s", e)
             if ttft_span:
                 ttft_span.add_event(
                     name="stop_reason",
@@ -664,9 +678,11 @@ class SimpleOpenAIStreamingInterface:
             message_delta = choice.delta
 
             if message_delta.content is not None and message_delta.content != "":
+                if prev_message_type and prev_message_type != "assistant_message":
+                    message_index += 1
                 assistant_msg = AssistantMessage(
                     id=self.letta_message_id,
-                    content=[TextContent(text=message_delta.content)],
+                    content=message_delta.content,
                     date=datetime.now(timezone.utc).isoformat(),
                     otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                     run_id=self.run_id,
@@ -674,9 +690,33 @@ class SimpleOpenAIStreamingInterface:
                 )
                 self.content_messages.append(assistant_msg)
                 prev_message_type = assistant_msg.message_type
-                message_index += 1  # Increment for the next message
                 yield assistant_msg
 
+            if (
+                hasattr(chunk, "choices")
+                and len(chunk.choices) > 0
+                and hasattr(chunk.choices[0], "delta")
+                and hasattr(chunk.choices[0].delta, "reasoning_content")
+            ):
+                delta = chunk.choices[0].delta
+                reasoning_content = getattr(delta, "reasoning_content", None)
+                if reasoning_content is not None and reasoning_content != "":
+                    if prev_message_type and prev_message_type != "reasoning_message":
+                        message_index += 1
+                    reasoning_msg = ReasoningMessage(
+                        id=self.letta_message_id,
+                        date=datetime.now(timezone.utc).isoformat(),
+                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        source="reasoner_model",
+                        reasoning=reasoning_content,
+                        signature=None,
+                        run_id=self.run_id,
+                        step_id=self.step_id,
+                    )
+                    self.content_messages.append(reasoning_msg)
+                    prev_message_type = reasoning_msg.message_type
+                    yield reasoning_msg
+
             if message_delta.tool_calls is not None and len(message_delta.tool_calls) > 0:
                 tool_call = message_delta.tool_calls[0]
 
@@ -710,7 +750,7 @@ class SimpleOpenAIStreamingInterface:
 
                 if self.requires_approval_tools:
                     tool_call_msg = ApprovalRequestMessage(
-                        id=self.letta_message_id,
+                        id=decrement_message_uuid(self.letta_message_id),
                         date=datetime.now(timezone.utc),
                         tool_call=ToolCallDelta(
                             name=tool_call.function.name,
@@ -718,11 +758,13 @@ class SimpleOpenAIStreamingInterface:
                             tool_call_id=tool_call.id,
                         ),
                         # name=name,
-                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
                 else:
+                    if prev_message_type and prev_message_type != "tool_call_message":
+                        message_index += 1
                     tool_call_delta = ToolCallDelta(
                         name=tool_call.function.name,
                         arguments=tool_call.function.arguments,
@@ -738,8 +780,7 @@ class SimpleOpenAIStreamingInterface:
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
-                prev_message_type = tool_call_msg.message_type
-                message_index += 1  # Increment for the next message
+                    prev_message_type = tool_call_msg.message_type
                 yield tool_call_msg
 
 
@@ -873,7 +914,7 @@ class SimpleOpenAIResponsesStreamingInterface:
         except Exception as e:
             import traceback
 
-            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            logger.exception("Error processing stream: %s", e)
             if ttft_span:
                 ttft_span.add_event(
                     name="stop_reason",
@@ -935,11 +976,9 @@ class SimpleOpenAIResponsesStreamingInterface:
                 # cache for approval if/elses
                 self.tool_call_name = name
                 if self.tool_call_name and self.tool_call_name in self.requires_approval_tools:
-                    if prev_message_type and prev_message_type != "approval_request_message":
-                        message_index += 1
                     yield ApprovalRequestMessage(
-                        id=self.letta_message_id,
-                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        id=decrement_message_uuid(self.letta_message_id),
+                        otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                         date=datetime.now(timezone.utc),
                         tool_call=ToolCallDelta(
                             name=name,
@@ -949,7 +988,6 @@ class SimpleOpenAIResponsesStreamingInterface:
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
-                    prev_message_type = "tool_call_message"
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
@@ -1105,11 +1143,9 @@ class SimpleOpenAIResponsesStreamingInterface:
             delta = event.delta
 
             if self.tool_call_name and self.tool_call_name in self.requires_approval_tools:
-                if prev_message_type and prev_message_type != "approval_request_message":
-                    message_index += 1
                 yield ApprovalRequestMessage(
-                    id=self.letta_message_id,
-                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                    id=decrement_message_uuid(self.letta_message_id),
+                    otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                     date=datetime.now(timezone.utc),
                     tool_call=ToolCallDelta(
                         name=None,
@@ -1119,7 +1155,6 @@ class SimpleOpenAIResponsesStreamingInterface:
                     run_id=self.run_id,
                     step_id=self.step_id,
                 )
-                prev_message_type = "approval_request_message"
             else:
                 if prev_message_type and prev_message_type != "tool_call_message":
                     message_index += 1

letta/llm_api/anthropic_client.py

@@ -439,6 +439,7 @@ class AnthropicClient(LLMClientBase):
             llm_config.model.startswith("claude-3-7-sonnet")
             or llm_config.model.startswith("claude-sonnet-4")
             or llm_config.model.startswith("claude-opus-4")
+            or llm_config.model.startswith("claude-haiku-4-5")
         )
 
     @trace_method
@@ -575,7 +576,7 @@ class AnthropicClient(LLMClientBase):
         reasoning_content = None
         reasoning_content_signature = None
         redacted_reasoning_content = None
-        tool_calls = None
+        tool_calls: list[ToolCall] = []
 
         if len(response.content) > 0:
             for content_part in response.content:
@@ -585,6 +586,8 @@ class AnthropicClient(LLMClientBase):
                     # hack for incorrect tool format
                     tool_input = json.loads(json.dumps(content_part.input))
                     if "id" in tool_input and tool_input["id"].startswith("toolu_") and "function" in tool_input:
+                        if isinstance(tool_input["function"], str):
+                            tool_input["function"] = json.loads(tool_input["function"])
                         arguments = json.dumps(tool_input["function"]["arguments"], indent=2)
                         try:
                             args_json = json.loads(arguments)
@@ -594,7 +597,7 @@ class AnthropicClient(LLMClientBase):
                             arguments = str(tool_input["function"]["arguments"])
                     else:
                         arguments = json.dumps(tool_input, indent=2)
-                    tool_calls = [
+                    tool_calls.append(
                         ToolCall(
                             id=content_part.id,
                             type="function",
@@ -603,7 +606,7 @@ class AnthropicClient(LLMClientBase):
                                 arguments=arguments,
                             ),
                         )
-                    ]
+                    )
                 if content_part.type == "thinking":
                     reasoning_content = content_part.thinking
                     reasoning_content_signature = content_part.signature
@@ -623,7 +626,7 @@ class AnthropicClient(LLMClientBase):
                 reasoning_content=reasoning_content,
                 reasoning_content_signature=reasoning_content_signature,
                 redacted_reasoning_content=redacted_reasoning_content,
-                tool_calls=tool_calls,
+                tool_calls=tool_calls or None,
             ),
         )
 

letta/llm_api/deepseek_client.py

@@ -1,7 +1,6 @@
 import json
 import os
 import re
-import warnings
 from typing import List, Optional
 
 from openai import AsyncOpenAI, AsyncStream, OpenAI
@@ -9,10 +8,13 @@ from openai.types.chat.chat_completion import ChatCompletion
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 
 from letta.llm_api.openai_client import OpenAIClient
+from letta.log import get_logger
 from letta.otel.tracing import trace_method
 from letta.schemas.enums import AgentType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
+
+logger = get_logger(__name__)
 from letta.schemas.openai.chat_completion_request import (
     AssistantMessage,
     ChatCompletionRequest,
@@ -91,7 +93,7 @@ def map_messages_to_deepseek_format(messages: List[ChatMessage]) -> List[_Messag
             merged_message = merge_tool_message(deepseek_messages[-1], message)
             deepseek_messages[-1] = merged_message
         else:
-            print(f"Skipping message: {message}")
+            logger.warning(f"Skipping message: {message}")
 
     # This needs to end on a user message, add a dummy message if the last was assistant
     if deepseek_messages[-1].role == "assistant":
@@ -127,7 +129,7 @@ def build_deepseek_chat_completions_request(
     if llm_config.model:
         model = llm_config.model
     else:
-        warnings.warn(f"Model type not set in llm_config: {llm_config.model_dump_json(indent=4)}")
+        logger.warning(f"Model type not set in llm_config: {llm_config.model_dump_json(indent=4)}")
         model = None
     if use_tool_naming:
         if function_call is None:
@@ -308,7 +310,7 @@ def convert_deepseek_response_to_chatcompletion(
             )
         ]
     except (json.JSONDecodeError, TypeError, KeyError) as e:
-        print(e)
+        logger.error(f"Failed to parse DeepSeek response: {e}")
         tool_calls = response.choices[0].message.tool_calls
         raise ValueError(f"Failed to create valid JSON {content}")
 

letta/llm_api/google_ai_client.py

@@ -92,10 +92,7 @@ async def google_ai_get_model_list_async(
     except httpx.HTTPStatusError as http_err:
         # Handle HTTP errors (e.g., response 4XX, 5XX)
         printd(f"Got HTTPError, exception={http_err}")
-        # Print the HTTP status code
-        print(f"HTTP Error: {http_err.response.status_code}")
-        # Print the response content (error message from server)
-        print(f"Message: {http_err.response.text}")
+        logger.error(f"HTTP Error: {http_err.response.status_code}, Message: {http_err.response.text}")
         raise http_err
 
     except httpx.RequestError as req_err:
@@ -136,10 +133,7 @@ def google_ai_get_model_details(base_url: str, api_key: str, model: str, key_in_
     except httpx.HTTPStatusError as http_err:
         # Handle HTTP errors (e.g., response 4XX, 5XX)
         printd(f"Got HTTPError, exception={http_err}")
-        # Print the HTTP status code
-        print(f"HTTP Error: {http_err.response.status_code}")
-        # Print the response content (error message from server)
-        print(f"Message: {http_err.response.text}")
+        logger.error(f"HTTP Error: {http_err.response.status_code}, Message: {http_err.response.text}")
         raise http_err
 
     except httpx.RequestError as req_err:
@@ -182,10 +176,7 @@ async def google_ai_get_model_details_async(
     except httpx.HTTPStatusError as http_err:
         # Handle HTTP errors (e.g., response 4XX, 5XX)
         printd(f"Got HTTPError, exception={http_err}")
-        # Print the HTTP status code
-        print(f"HTTP Error: {http_err.response.status_code}")
-        # Print the response content (error message from server)
-        print(f"Message: {http_err.response.text}")
+        logger.error(f"HTTP Error: {http_err.response.status_code}, Message: {http_err.response.text}")
         raise http_err
 
     except httpx.RequestError as req_err:

letta/llm_api/google_vertex_client.py

@@ -128,7 +128,7 @@ class GoogleVertexClient(LLMClientBase):
                                         logger.warning(
                                             f"Modified heartbeat message with special character warning for retry {retry_count}/{self.MAX_RETRIES}"
                                         )
-                                except (json.JSONDecodeError, TypeError):
+                                except (json.JSONDecodeError, TypeError, AttributeError):
                                     # Not a JSON message or not a heartbeat, skip modification
                                     pass
 

letta/llm_api/helpers.py

@@ -1,6 +1,5 @@
 import copy
 import json
-import warnings
 from collections import OrderedDict
 from typing import Any, List, Union
 
@@ -8,24 +7,77 @@ import requests
 
 from letta.constants import OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING
 from letta.helpers.json_helpers import json_dumps
+from letta.log import get_logger
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice
 from letta.settings import summarizer_settings
 from letta.utils import count_tokens, printd
 
+logger = get_logger(__name__)
+
 
 def _convert_to_structured_output_helper(property: dict) -> dict:
     """Convert a single JSON schema property to structured output format (recursive)"""
 
+    # Handle anyOf structures
+    if "anyOf" in property and "type" not in property:
+        # Check if this is a simple anyOf that can be flattened to type array
+        types = []
+        has_complex = False
+        for option in property["anyOf"]:
+            if "type" in option:
+                opt_type = option["type"]
+                if opt_type in ["object", "array"]:
+                    has_complex = True
+                    break
+                types.append(opt_type)
+            elif "$ref" in option:
+                # Has unresolved $ref, treat as complex
+                has_complex = True
+                break
+
+        # If it's simple primitives only (string, null, integer, boolean, etc), flatten to type array
+        if not has_complex and types:
+            param_description = property.get("description")
+            property_dict = {"type": types}
+            if param_description is not None:
+                property_dict["description"] = param_description
+            if "default" in property:
+                property_dict["default"] = property["default"]
+            # Preserve other fields like enum, format, etc
+            for key in ["enum", "format", "pattern", "minLength", "maxLength", "minimum", "maximum"]:
+                if key in property:
+                    property_dict[key] = property[key]
+            return property_dict
+
+        # Otherwise, preserve anyOf and recursively process each option
+        property_dict = {"anyOf": [_convert_to_structured_output_helper(opt) for opt in property["anyOf"]]}
+        if "description" in property:
+            property_dict["description"] = property["description"]
+        if "default" in property:
+            property_dict["default"] = property["default"]
+        if "title" in property:
+            property_dict["title"] = property["title"]
+        return property_dict
+
     if "type" not in property:
-        raise ValueError(f"Property {property} is missing a type")
+        raise ValueError(f"Property {property} is missing a type and doesn't have anyOf")
+
     param_type = property["type"]
+    param_description = property.get("description")
 
-    if "description" not in property:
-        # raise ValueError(f"Property {property} is missing a description")
-        param_description = None
-    else:
-        param_description = property["description"]
+    # Handle type arrays (e.g., ["string", "null"])
+    if isinstance(param_type, list):
+        property_dict = {"type": param_type}
+        if param_description is not None:
+            property_dict["description"] = param_description
+        if "default" in property:
+            property_dict["default"] = property["default"]
+        # Preserve other fields
+        for key in ["enum", "format", "pattern", "minLength", "maxLength", "minimum", "maximum", "title"]:
+            if key in property:
+                property_dict[key] = property[key]
+        return property_dict
 
     if param_type == "object":
         if "properties" not in property:
@@ -39,6 +91,8 @@ def _convert_to_structured_output_helper(property: dict) -> dict:
         }
         if param_description is not None:
             property_dict["description"] = param_description
+        if "title" in property:
+            property_dict["title"] = property["title"]
         return property_dict
 
     elif param_type == "array":
@@ -51,6 +105,8 @@ def _convert_to_structured_output_helper(property: dict) -> dict:
         }
         if param_description is not None:
             property_dict["description"] = param_description
+        if "title" in property:
+            property_dict["title"] = property["title"]
         return property_dict
 
     else:
@@ -59,6 +115,10 @@ def _convert_to_structured_output_helper(property: dict) -> dict:
         }
         if param_description is not None:
             property_dict["description"] = param_description
+        # Preserve other fields
+        for key in ["enum", "format", "pattern", "minLength", "maxLength", "minimum", "maximum", "default", "title"]:
+            if key in property:
+                property_dict[key] = property[key]
         return property_dict
 
 
@@ -66,6 +126,14 @@ def convert_to_structured_output(openai_function: dict, allow_optional: bool = F
     """Convert function call objects to structured output objects.
 
     See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas
+
+    Supports:
+    - Simple type arrays: type: ["string", "null"]
+    - anyOf with primitives (flattened to type array)
+    - anyOf with complex objects (preserved as anyOf)
+    - Nested structures with recursion
+
+    For OpenAI strict mode, optional fields (not in required) must have explicit default values.
     """
     description = openai_function.get("description", "")
 
@@ -82,57 +150,19 @@ def convert_to_structured_output(openai_function: dict, allow_optional: bool = F
     }
 
     for param, details in openai_function["parameters"]["properties"].items():
-        param_type = details["type"]
-        param_description = details.get("description", "")
-
-        if param_type == "object":
-            if "properties" not in details:
-                raise ValueError(f"Property {param} of type object is missing 'properties'")
-            structured_output["parameters"]["properties"][param] = {
-                "type": "object",
-                "description": param_description,
-                "properties": {k: _convert_to_structured_output_helper(v) for k, v in details["properties"].items()},
-                "additionalProperties": False,
-                "required": list(details["properties"].keys()),
-            }
-
-        elif param_type == "array":
-            items_schema = details.get("items")
-            prefix_items_schema = details.get("prefixItems")
-
-            if prefix_items_schema:
-                # assume fixed-length tuple — safe fallback to use first type for items
-                fallback_item = prefix_items_schema[0] if isinstance(prefix_items_schema, list) else prefix_items_schema
-                structured_output["parameters"]["properties"][param] = {
-                    "type": "array",
-                    "description": param_description,
-                    "prefixItems": [_convert_to_structured_output_helper(item) for item in prefix_items_schema],
-                    "items": _convert_to_structured_output_helper(fallback_item),
-                    "minItems": details.get("minItems", len(prefix_items_schema)),
-                    "maxItems": details.get("maxItems", len(prefix_items_schema)),
-                }
-            elif items_schema:
-                structured_output["parameters"]["properties"][param] = {
-                    "type": "array",
-                    "description": param_description,
-                    "items": _convert_to_structured_output_helper(items_schema),
-                }
-            else:
-                raise ValueError(f"Array param '{param}' is missing both 'items' and 'prefixItems'")
-
-        else:
-            prop = {
-                "type": param_type,
-                "description": param_description,
-            }
-            if "enum" in details:
-                prop["enum"] = details["enum"]
-            structured_output["parameters"]["properties"][param] = prop
+        # Use the helper for all parameter types - it now handles anyOf, type arrays, objects, arrays, etc.
+        structured_output["parameters"]["properties"][param] = _convert_to_structured_output_helper(details)
 
+    # Determine which fields are required
+    # For OpenAI strict mode, ALL fields must be in the required array
+    # This is a requirement for strict: true schemas
     if not allow_optional:
+        # All fields are required for strict mode
         structured_output["parameters"]["required"] = list(structured_output["parameters"]["properties"].keys())
     else:
-        raise NotImplementedError("Optional parameter handling is not implemented.")
+        # Use the input's required list if provided, otherwise empty
+        structured_output["parameters"]["required"] = openai_function["parameters"].get("required", [])
+
     return structured_output
 
 
@@ -269,7 +299,7 @@ def unpack_inner_thoughts_from_kwargs(choice: Choice, inner_thoughts_key: str) -
 
     if message.role == "assistant" and message.tool_calls and len(message.tool_calls) >= 1:
         if len(message.tool_calls) > 1:
-            warnings.warn(f"Unpacking inner thoughts from more than one tool call ({len(message.tool_calls)}) is not supported")
+            logger.warning(f"Unpacking inner thoughts from more than one tool call ({len(message.tool_calls)}) is not supported")
         # TODO support multiple tool calls
         tool_call = message.tool_calls[0]
 
@@ -285,21 +315,20 @@ def unpack_inner_thoughts_from_kwargs(choice: Choice, inner_thoughts_key: str) -
                 new_choice.message.tool_calls[0].function.arguments = json_dumps(func_args)
                 # also replace the message content
                 if new_choice.message.content is not None:
-                    warnings.warn(f"Overwriting existing inner monologue ({new_choice.message.content}) with kwarg ({inner_thoughts})")
+                    logger.warning(f"Overwriting existing inner monologue ({new_choice.message.content}) with kwarg ({inner_thoughts})")
                 new_choice.message.content = inner_thoughts
 
                 # update the choice object
                 rewritten_choice = new_choice
             else:
-                warnings.warn(f"Did not find inner thoughts in tool call: {str(tool_call)}")
+                logger.warning(f"Did not find inner thoughts in tool call: {str(tool_call)}")
 
         except json.JSONDecodeError as e:
-            warnings.warn(f"Failed to strip inner thoughts from kwargs: {e}")
-            print(f"\nFailed to strip inner thoughts from kwargs: {e}")
-            print(f"\nTool call arguments: {tool_call.function.arguments}")
+            logger.warning(f"Failed to strip inner thoughts from kwargs: {e}")
+            logger.error(f"Failed to strip inner thoughts from kwargs: {e}, Tool call arguments: {tool_call.function.arguments}")
             raise e
     else:
-        warnings.warn(f"Did not find tool call in message: {str(message)}")
+        logger.warning(f"Did not find tool call in message: {str(message)}")
 
     return rewritten_choice