llama-index-llms-openai 0.4.2__tar.gz → 0.4.4__tar.gz

{llama_index_llms_openai-0.4.2 → llama_index_llms_openai-0.4.4}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: llama-index-llms-openai
-Version: 0.4.2
+Version: 0.4.4
 Summary: llama-index llms openai integration
 Author: llama-index
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: <4.0,>=3.9
-Requires-Dist: llama-index-core<0.13,>=0.12.37
+Requires-Dist: llama-index-core<0.13,>=0.12.41
 Requires-Dist: openai<2,>=1.81.0
 Description-Content-Type: text/markdown
 

{llama_index_llms_openai-0.4.2 → llama_index_llms_openai-0.4.4}/llama_index/llms/openai/base.py

@@ -77,6 +77,7 @@ from llama_index.llms.openai.utils import (
     resolve_tool_choice,
     to_openai_message_dicts,
     update_tool_calls,
+    is_json_schema_supported,
 )
 from openai import AsyncOpenAI, AzureOpenAI, AsyncAzureOpenAI
 from openai import OpenAI as SyncOpenAI
@@ -1000,6 +1001,23 @@ class OpenAI(FunctionCallingLLM):
 
         return tool_selections
 
+    def _prepare_schema(
+        self, llm_kwargs: Optional[Dict[str, Any]], output_cls: Type[Model]
+    ) -> Dict[str, Any]:
+        from openai.resources.beta.chat.completions import _type_to_response_format
+
+        llm_kwargs = llm_kwargs or {}
+        llm_kwargs["response_format"] = _type_to_response_format(output_cls)
+        if "tool_choice" in llm_kwargs:
+            del llm_kwargs["tool_choice"]
+        return llm_kwargs
+
+    def _should_use_structure_outputs(self):
+        return (
+            self.pydantic_program_mode == PydanticProgramMode.DEFAULT
+            and is_json_schema_supported(self.model)
+        )
+
     @dispatcher.span
     def structured_predict(
         self,
@@ -1011,11 +1029,17 @@ class OpenAI(FunctionCallingLLM):
         """Structured predict."""
         llm_kwargs = llm_kwargs or {}
 
+        if self._should_use_structure_outputs():
+            messages = self._extend_messages(prompt.format_messages(**prompt_args))
+            llm_kwargs = self._prepare_schema(llm_kwargs, output_cls)
+            response = self.chat(messages, **llm_kwargs)
+            return output_cls.model_validate_json(str(response.message.content))
+
+        # when uses function calling to extract structured outputs
+        # here we force tool_choice to be required
         llm_kwargs["tool_choice"] = (
             "required" if "tool_choice" not in llm_kwargs else llm_kwargs["tool_choice"]
         )
-        # by default structured prediction uses function calling to extract structured outputs
-        # here we force tool_choice to be required
         return super().structured_predict(
             output_cls, prompt, llm_kwargs=llm_kwargs, **prompt_args
         )
@@ -1031,15 +1055,91 @@ class OpenAI(FunctionCallingLLM):
         """Structured predict."""
         llm_kwargs = llm_kwargs or {}
 
+        if self._should_use_structure_outputs():
+            messages = self._extend_messages(prompt.format_messages(**prompt_args))
+            llm_kwargs = self._prepare_schema(llm_kwargs, output_cls)
+            response = await self.achat(messages, **llm_kwargs)
+            return output_cls.model_validate_json(str(response.message.content))
+
+        # when uses function calling to extract structured outputs
+        # here we force tool_choice to be required
         llm_kwargs["tool_choice"] = (
             "required" if "tool_choice" not in llm_kwargs else llm_kwargs["tool_choice"]
         )
-        # by default structured prediction uses function calling to extract structured outputs
-        # here we force tool_choice to be required
         return await super().astructured_predict(
             output_cls, prompt, llm_kwargs=llm_kwargs, **prompt_args
         )
 
+    def _structured_stream_call(
+        self,
+        output_cls: Type[Model],
+        prompt: PromptTemplate,
+        llm_kwargs: Optional[Dict[str, Any]] = None,
+        **prompt_args: Any,
+    ) -> Generator[
+        Union[Model, List[Model], "FlexibleModel", List["FlexibleModel"]], None, None
+    ]:
+        if self._should_use_structure_outputs():
+            from llama_index.core.program.streaming_utils import (
+                process_streaming_content_incremental,
+            )
+
+            messages = self._extend_messages(prompt.format_messages(**prompt_args))
+            llm_kwargs = self._prepare_schema(llm_kwargs, output_cls)
+            curr = None
+            for response in self.stream_chat(messages, **llm_kwargs):
+                curr = process_streaming_content_incremental(response, output_cls, curr)
+                yield curr
+        else:
+            llm_kwargs["tool_choice"] = (
+                "required"
+                if "tool_choice" not in llm_kwargs
+                else llm_kwargs["tool_choice"]
+            )
+            yield from super()._structured_stream_call(
+                output_cls, prompt, llm_kwargs, **prompt_args
+            )
+
+    async def _structured_astream_call(
+        self,
+        output_cls: Type[Model],
+        prompt: PromptTemplate,
+        llm_kwargs: Optional[Dict[str, Any]] = None,
+        **prompt_args: Any,
+    ) -> AsyncGenerator[
+        Union[Model, List[Model], "FlexibleModel", List["FlexibleModel"]], None
+    ]:
+        if self._should_use_structure_outputs():
+
+            async def gen(
+                llm_kwargs=llm_kwargs,
+            ) -> AsyncGenerator[
+                Union[Model, List[Model], FlexibleModel, List[FlexibleModel]], None
+            ]:
+                from llama_index.core.program.streaming_utils import (
+                    process_streaming_content_incremental,
+                )
+
+                messages = self._extend_messages(prompt.format_messages(**prompt_args))
+                llm_kwargs = self._prepare_schema(llm_kwargs, output_cls)
+                curr = None
+                async for response in await self.astream_chat(messages, **llm_kwargs):
+                    curr = process_streaming_content_incremental(
+                        response, output_cls, curr
+                    )
+                    yield curr
+
+            return gen()
+        else:
+            llm_kwargs["tool_choice"] = (
+                "required"
+                if "tool_choice" not in llm_kwargs
+                else llm_kwargs["tool_choice"]
+            )
+            return await super()._structured_astream_call(
+                output_cls, prompt, llm_kwargs, **prompt_args
+            )
+
     @dispatcher.span
     def stream_structured_predict(
         self,
@@ -1051,11 +1151,6 @@ class OpenAI(FunctionCallingLLM):
         """Stream structured predict."""
         llm_kwargs = llm_kwargs or {}
 
-        llm_kwargs["tool_choice"] = (
-            "required" if "tool_choice" not in llm_kwargs else llm_kwargs["tool_choice"]
-        )
-        # by default structured prediction uses function calling to extract structured outputs
-        # here we force tool_choice to be required
         return super().stream_structured_predict(
             output_cls, prompt, llm_kwargs=llm_kwargs, **prompt_args
         )
@@ -1070,12 +1165,6 @@ class OpenAI(FunctionCallingLLM):
     ) -> AsyncGenerator[Union[Model, FlexibleModel], None]:
         """Stream structured predict."""
         llm_kwargs = llm_kwargs or {}
-
-        llm_kwargs["tool_choice"] = (
-            "required" if "tool_choice" not in llm_kwargs else llm_kwargs["tool_choice"]
-        )
-        # by default structured prediction uses function calling to extract structured outputs
-        # here we force tool_choice to be required
         return await super().astream_structured_predict(
             output_cls, prompt, llm_kwargs=llm_kwargs, **prompt_args
         )

{llama_index_llms_openai-0.4.2 → llama_index_llms_openai-0.4.4}/llama_index/llms/openai/responses.py

@@ -831,7 +831,10 @@ class OpenAIResponses(FunctionCallingLLM):
 
         # openai responses api has a slightly different tool spec format
         tool_specs = [
-            {"type": "function", **tool.metadata.to_openai_tool()["function"]}
+            {
+                "type": "function",
+                **tool.metadata.to_openai_tool(skip_length_check=True)["function"],
+            }
             for tool in tools
         ]
 

{llama_index_llms_openai-0.4.2 → llama_index_llms_openai-0.4.4}/llama_index/llms/openai/utils.py

@@ -180,6 +180,32 @@ DISCONTINUED_MODELS = {
     "code-cushman-001": 2048,
 }
 
+JSON_SCHEMA_MODELS = [
+    "o4-mini",
+    "o1",
+    "o1-pro",
+    "o3",
+    "o3-mini",
+    "gpt-4.1",
+    "gpt-4o",
+    "gpt-4.1",
+]
+
+
+def is_json_schema_supported(model: str) -> bool:
+    try:
+        from openai.resources.beta.chat import completions
+
+        if not hasattr(completions, "_type_to_response_format"):
+            return False
+
+        return not model.startswith("o1-mini") and any(
+            model.startswith(m) for m in JSON_SCHEMA_MODELS
+        )
+    except ImportError:
+        return False
+
+
 MISSING_API_KEY_ERROR_MESSAGE = """No API key found for OpenAI.
 Please set either the OPENAI_API_KEY environment variable or \
 openai.api_key prior to initialization.

{llama_index_llms_openai-0.4.2 → llama_index_llms_openai-0.4.4}/pyproject.toml

@@ -27,13 +27,13 @@ dev = [
 
 [project]
 name = "llama-index-llms-openai"
-version = "0.4.2"
+version = "0.4.4"
 description = "llama-index llms openai integration"
 authors = [{name = "llama-index"}]
 requires-python = ">=3.9,<4.0"
 readme = "README.md"
 license = "MIT"
-dependencies = ["openai>=1.81.0,<2", "llama-index-core>=0.12.37,<0.13"]
+dependencies = ["openai>=1.81.0,<2", "llama-index-core>=0.12.41,<0.13"]
 
 [tool.codespell]
 check-filenames = true