"function": {
            "name": "get_weather",
            "strict": True,
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"},
                    "unit": {"type": "string", "enum": ["c", "f"]},
                },
                "required": ["location", "unit"],
                "additionalProperties": False,
            },
        },

    class Config:
        # Disallow additional properties. Needed for OpenAI pydantic program mode
        extra = 'forbid'  

    def _prepare_chat_with_tools(
        self,
        tools: List["BaseTool"],
        user_msg: Optional[Union[str, ChatMessage]] = None,
        chat_history: Optional[List[ChatMessage]] = None,
        verbose: bool = False,
        allow_parallel_tool_calls: bool = False,
        tool_choice: Union[str, dict] = "auto",
        strict: Optional[bool] = None,
        **kwargs: Any,
    ) -> Dict[str, Any]:
        """Predict and call the tool."""
        tool_specs = [tool.metadata.to_openai_tool() for tool in tools]

        # if strict is passed in, use, else default to the class-level attribute, else default to True`
        if strict is not None:
            strict = strict
        else:
            strict = self.strict

        self.llm = OpenAIFixedForStructuredOutput(
        # self.llm = OpenAI(
            model=self.persona.meta.llm_model,
            temperature=temperature,
            max_tokens=max_output_tokens,
            api_key=OpenAiPersonaLlm.TOKEN,
            # timeout=300
            timeout=60,
            # This is important to use openai's native structured output
            # pydantic_program_mode=PydanticProgramMode.DEFAULT,
            pydantic_program_mode=PydanticProgramMode.OPENAI,
            # pydantic_program_mode=PydanticProgramMode.FUNCTION,
            
            # Update: Llamaindex just disregards it, might be because of PydanticProgramMode.OPENAI, TODO investigate
            # IMPORTANT FOR STRUCTURED OUTPUT, OTHERWISE THIS MODE DOESN'T SEEM TO BE "ACTIVATED" 
            #  AT OPENAI'S SIDE AND IT SILENTLY CONTINUES WITH NORMAL MODE
            strict=True
        )

...

# And the custom OpenAI llm class (provided for completeness but I don't think it's relevant to the issue)
class OpenAIFixedForStructuredOutput(OpenAI):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        assert self.pydantic_program_mode == PydanticProgramMode.OPENAI, "Pydantic program mode must be OPENAI for this fixed version of OpenAI llm class"

    @dispatcher.span
    def structured_predict(
        self, *args: Any, llm_kwargs: Optional[Dict[str, Any]] = None, **kwargs: Any
    ) -> BaseModel:
        assert not llm_kwargs, "llm_kwargs not supported in this fixed version of OpenAI llm class"
        llm_kwargs = llm_kwargs or {}
        # Skipping one base class (OpenAI) since that's what we're trying to fix 
        # TODO consider monkey patching as it might be more "pythonic"
        return super(FunctionCallingLLM, self).structured_predict(*args, llm_kwargs=llm_kwargs, **kwargs)
    
    # Check base class for what we are overriding
    @dispatcher.span
    async def astructured_predict(
        self, *args: Any, llm_kwargs: Optional[Dict[str, Any]] = None, **kwargs: Any
    ) -> BaseModel:
        assert not llm_kwargs, "llm_kwargs not supported in this fixed version of OpenAI llm class"
        llm_kwargs = llm_kwargs or {}
        # Skipping one base class (OpenAI) since that's what we're trying to fix 
        # TODO consider monkey patching as it might be more "pythonic"
        return await super(FunctionCallingLLM, self).astructured_predict(*args, llm_kwargs=llm_kwargs, **kwargs)
    
    @dispatcher.span
    def stream_structured_predict(
        self, *args: Any, llm_kwargs: Optional[Dict[str, Any]] = None, **kwargs: Any
    ) -> Generator[Union[Model, List[Model]], None, None]:
        assert not llm_kwargs, "llm_kwargs not supported in this fixed version of OpenAI llm class"
        llm_kwargs = llm_kwargs or {}
        # Skipping one base class (OpenAI) since that's what we're trying to fix 
        # TODO consider monkey patching as it might be more "pythonic"
        return super(FunctionCallingLLM, self).stream_structured_predict(*args, llm_kwargs=llm_kwargs, **kwargs)

@deprecated("Please use `FunctionCallingProgram` instead.")
class OpenAIPydanticProgram(BaseLLMFunctionProgram[LLM]):

class PydanticProgramMode(str, Enum):
    """Pydantic program mode."""

    DEFAULT = "default"
    OPENAI = "openai"
    LLM = "llm"
    FUNCTION = "function"
    GUIDANCE = "guidance"
    LM_FORMAT_ENFORCER = "lm-format-enforcer"

        resp: Question = await pllm.llm.astructured_predict(
            Question, PromptTemplate(prompt),
            llm_kwargs=pllm.get_additional_kwargs_for_structured_output(Question)
        )

    # LLlamaindex doesn't do this
    # https://platform.openai.com/docs/guides/structured-outputs#structured-outputs-vs-json-mode
    def get_additional_kwargs_for_structured_output(self, output_model: Type[BaseModel]):
        return {
            'response_format': {
                'type': 'json_schema',
                'json_schema': {
                    # TODO consider pascal_to_snake to have snake-case IF needed
                    'name': output_model.__name__,
                    'description': output_model.model_config.get('description', output_model.__doc__),
                    'strict': True,
                    'schema': output_model.model_json_schema()
                }
            }
        }