openai-sdk-helpers 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

openai_sdk_helpers/agent/base.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
+import logging
+import traceback
+import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, Optional, Protocol, cast
-import uuid
 
 from agents import Agent, Handoff, InputGuardrail, OutputGuardrail, Session
 from agents.model_settings import ModelSettings
@@ -13,7 +15,6 @@ from agents.tool import Tool
 from jinja2 import Template
 
 from ..environment import get_data_path
-
 from ..utils.json.data_class import DataclassJSONSerializable
 from ..structure.base import StructureBase
 from ..tools import (
@@ -183,6 +184,8 @@ class AgentBase(DataclassJSONSerializable):
         Return response tool handler and definition for Responses API use.
     build_response(openai_settings, data_path=None, tool_handlers=None, system_vector_store=None)
         Build a ResponseBase instance based on this agent.
+    save_error(exc)
+        Persist error details to a file named with the agent UUID.
     close()
         Clean up agent resources (can be overridden by subclasses).
     """
@@ -237,8 +240,6 @@ class AgentBase(DataclassJSONSerializable):
             else:
                 self._data_path = data_path_obj / class_name
         else:
-            from ..environment import get_data_path
-
             self._data_path = get_data_path(self.__class__.__name__)
 
         self._input_structure = configuration.input_structure
@@ -487,13 +488,29 @@ class AgentBase(DataclassJSONSerializable):
             output_structure = self._output_structure
         # Use session from parameter, fall back to configuration session
         session_to_use = session if session is not None else self._session
-        return await run_async(
-            agent=self.get_agent(),
-            input=input,
-            context=context,
-            output_structure=output_structure,
-            session=session_to_use,
-        )
+        try:
+            return await run_async(
+                agent=self.get_agent(),
+                input=input,
+                context=context,
+                output_structure=output_structure,
+                session=session_to_use,
+            )
+        except Exception as exc:
+            try:
+                self.save_error(exc)
+            except Exception as save_exc:
+                log(
+                    f"Failed to save error details for agent {self.uuid}: {save_exc}",
+                    level=logging.ERROR,
+                    exc=save_exc,
+                )
+            log(
+                f"Error running agent '{self.name}': {exc}",
+                level=logging.ERROR,
+                exc=exc,
+            )
+            raise
 
     def run_sync(
         self,
@@ -526,13 +543,29 @@ class AgentBase(DataclassJSONSerializable):
             output_structure = self._output_structure
         # Use session from parameter, fall back to configuration session
         session_to_use = session if session is not None else self._session
-        return run_sync(
-            agent=self.get_agent(),
-            input=input,
-            context=context,
-            output_structure=output_structure,
-            session=session_to_use,
-        )
+        try:
+            return run_sync(
+                agent=self.get_agent(),
+                input=input,
+                context=context,
+                output_structure=output_structure,
+                session=session_to_use,
+            )
+        except Exception as exc:
+            try:
+                self.save_error(exc)
+            except Exception as save_exc:
+                log(
+                    f"Failed to save error details for agent {self.uuid}: {save_exc}",
+                    level=logging.ERROR,
+                    exc=save_exc,
+                )
+            log(
+                f"Error running agent '{self.name}': {exc}",
+                level=logging.ERROR,
+                exc=exc,
+            )
+            raise
 
     def as_tool(self) -> Tool:
         """Return the agent as a callable tool.
@@ -731,5 +764,35 @@ class AgentBase(DataclassJSONSerializable):
         self.to_json_file(filepath=checked)
         log(f"Saved messages to {target}")
 
+    def save_error(self, exc: BaseException) -> Path:
+        """Persist error details to a file named with the agent UUID.
+
+        Parameters
+        ----------
+        exc : BaseException
+            Exception instance to serialize.
+
+        Returns
+        -------
+        Path
+            Path to the error file written to disk.
+
+        Examples
+        --------
+        >>> try:
+        ...     agent.run_sync("trigger error")
+        ... except Exception as exc:
+        ...     agent.save_error(exc)
+        """
+        error_text = "".join(
+            traceback.format_exception(type(exc), exc, exc.__traceback__)
+        )
+        filename = f"{str(self.uuid).lower()}_error.txt"
+        target = self._data_path / self.name / filename
+        checked = check_filepath(filepath=target)
+        checked.write_text(error_text, encoding="utf-8")
+        log(f"Saved error details to {checked}")
+        return checked
+
 
 __all__ = ["AgentConfigurationProtocol", "AgentBase"]

openai_sdk_helpers/files_api.py

@@ -374,6 +374,7 @@ class FilesAPIManager:
                 log(
                     f"Error deleting tracked file {file_id}: {exc}",
                     level=logging.WARNING,
+                    exc=exc,
                 )
                 results[file_id] = False
 

openai_sdk_helpers/logging.py

@@ -8,6 +8,7 @@ def log(
     level: int = logging.INFO,
     *,
     logger_name: str = "openai_sdk_helpers",
+    exc: BaseException | None = None,
 ) -> None:
     """Log a message using Python's standard logging.
 
@@ -20,6 +21,13 @@ def log(
         Default is logging.INFO.
     logger_name : str
         Name of the logger. Default is "openai_sdk_helpers".
+    exc : BaseException or None, optional
+        Exception instance to include with the log record. Default is None.
+
+    Returns
+    -------
+    None
+        Return None after emitting the log entry.
 
     Examples
     --------
@@ -28,7 +36,10 @@ def log(
     >>> log("Debug info", level=logging.DEBUG)
     """
     logger = logging.getLogger(logger_name)
-    logger.log(level, message)
+    exc_info = None
+    if exc is not None:
+        exc_info = (type(exc), exc, exc.__traceback__)
+    logger.log(level, message, exc_info=exc_info)
 
 
 __all__ = ["log"]

openai_sdk_helpers/response/base.py

@@ -13,6 +13,7 @@ import inspect
 import json
 import logging
 import threading
+import traceback
 import uuid
 from pathlib import Path
 from typing import (
@@ -137,6 +138,8 @@ class ResponseBase(Generic[T]):
         Construct a StreamlitAppConfig using this class as the builder.
     save(filepath=None)
         Serialize the message history to a JSON file.
+    save_error(exc)
+        Persist error details to a file named with the response UUID.
     close()
         Clean up remote resources including vector stores.
 
@@ -447,6 +450,9 @@ class ResponseBase(Generic[T]):
         When use_vector_store is True, this method automatically creates
         a vector store and adds a file_search tool for document retrieval.
         Images are always base64-encoded regardless of this setting.
+        When multiple content strings are provided, file attachments are
+        included only with the first message to avoid duplicating input
+        files across messages.
 
         Examples
         --------
@@ -470,8 +476,17 @@ class ResponseBase(Generic[T]):
             self, all_files, use_vector_store
         )
 
-        # Add each content as a separate message with the same attachments
-        for raw_content in contents:
+        attachments: list[
+            ResponseInputFileParam
+            | ResponseInputFileContentParam
+            | ResponseInputImageContentParam
+        ] = []
+        attachments.extend(vector_file_refs)
+        attachments.extend(base64_files)
+        attachments.extend(image_contents)
+
+        # Add each content as a separate message.
+        for index, raw_content in enumerate(contents):
             processed_text = raw_content.strip()
             input_content: list[
                 ResponseInputTextParam
@@ -480,14 +495,8 @@ class ResponseBase(Generic[T]):
                 | ResponseInputImageContentParam
             ] = [ResponseInputTextParam(type="input_text", text=processed_text)]
 
-            # Add vector store file references
-            input_content.extend(vector_file_refs)
-
-            # Add base64 files
-            input_content.extend(base64_files)
-
-            # Add images
-            input_content.extend(image_contents)
+            if index == 0:
+                input_content.extend(attachments)
 
             message = cast(
                 ResponseInputItemParam,
@@ -555,96 +564,117 @@ class ResponseBase(Generic[T]):
         log(f"{self.__class__.__name__}::run_response")
         parsed_result: T | None = None
 
-        self._build_input(
-            content=content,
-            files=(ensure_list(files) if files else None),
-            use_vector_store=use_vector_store,
-        )
-
-        kwargs = {
-            "input": self.messages.to_openai_payload(),
-            "model": self._model,
-        }
-        if not self._tools and self._output_structure is not None:
-            kwargs["text"] = self._output_structure.response_format()
-
-        if self._tools:
-            kwargs["tools"] = self._tools
-            kwargs["tool_choice"] = "auto"
-        response = self._client.responses.create(**kwargs)
+        try:
+            self._build_input(
+                content=content,
+                files=(ensure_list(files) if files else None),
+                use_vector_store=use_vector_store,
+            )
 
-        if not response.output:
-            log("No output returned from OpenAI.", level=logging.ERROR)
-            raise RuntimeError("No output returned from OpenAI.")
+            kwargs = {
+                "input": self.messages.to_openai_payload(),
+                "model": self._model,
+            }
+            if not self._tools and self._output_structure is not None:
+                kwargs["text"] = self._output_structure.response_format()
 
-        for response_output in response.output:
-            if isinstance(response_output, ResponseFunctionToolCall):
-                log(
-                    f"Tool call detected. Executing {response_output.name}.",
-                    level=logging.INFO,
-                )
+            if self._tools:
+                kwargs["tools"] = self._tools
+                kwargs["tool_choice"] = "auto"
+            response = self._client.responses.create(**kwargs)
 
-                tool_name = response_output.name
-                registration = self._tool_handlers.get(tool_name)
+            if not response.output:
+                log("No output returned from OpenAI.", level=logging.ERROR)
+                raise RuntimeError("No output returned from OpenAI.")
 
-                if registration is None:
+            for response_output in response.output:
+                if isinstance(response_output, ResponseFunctionToolCall):
                     log(
-                        f"No handler found for tool '{tool_name}'",
-                        level=logging.ERROR,
+                        f"Tool call detected. Executing {response_output.name}.",
+                        level=logging.INFO,
                     )
-                    raise ValueError(f"No handler for tool: {tool_name}")
 
-                handler = registration.handler
-                tool_spec = registration.tool_spec
+                    tool_name = response_output.name
+                    registration = self._tool_handlers.get(tool_name)
 
-                try:
-                    if inspect.iscoroutinefunction(handler):
-                        tool_result_json = await handler(response_output)
-                    else:
-                        tool_result_json = handler(response_output)
-                    if isinstance(tool_result_json, str):
-                        tool_result = json.loads(tool_result_json)
-                        tool_output = tool_result_json
+                    if registration is None:
+                        log(
+                            f"No handler found for tool '{tool_name}'",
+                            level=logging.ERROR,
+                        )
+                        raise ValueError(f"No handler for tool: {tool_name}")
+
+                    handler = registration.handler
+                    tool_spec = registration.tool_spec
+
+                    try:
+                        if inspect.iscoroutinefunction(handler):
+                            tool_result_json = await handler(response_output)
+                        else:
+                            tool_result_json = handler(response_output)
+                        if isinstance(tool_result_json, str):
+                            tool_result = json.loads(tool_result_json)
+                            tool_output = tool_result_json
+                        else:
+                            tool_result = coerce_jsonable(tool_result_json)
+                            tool_output = json.dumps(tool_result, cls=customJSONEncoder)
+                        self.messages.add_tool_message(
+                            content=response_output, output=tool_output
+                        )
+                        self.save()
+                    except Exception as exc:
+                        log(
+                            f"Error executing tool handler '{tool_name}': {exc}",
+                            level=logging.ERROR,
+                            exc=exc,
+                        )
+                        raise RuntimeError(
+                            f"Error in tool handler '{tool_name}': {exc}"
+                        )
+
+                    if tool_spec is not None:
+                        output_dict = tool_spec.output_structure.from_json(tool_result)
+                        parsed_result = cast(T, output_dict)
+                    elif self._output_structure:
+                        output_dict = self._output_structure.from_json(tool_result)
+                        parsed_result = output_dict
                     else:
-                        tool_result = coerce_jsonable(tool_result_json)
-                        tool_output = json.dumps(tool_result, cls=customJSONEncoder)
-                    self.messages.add_tool_message(
-                        content=response_output, output=tool_output
+                        print(tool_result)
+                        parsed_result = cast(T, tool_result)
+
+                if isinstance(response_output, ResponseOutputMessage):
+                    self.messages.add_assistant_message(
+                        response_output, metadata=kwargs
                     )
                     self.save()
-                except Exception as exc:
-                    log(
-                        f"Error executing tool handler '{tool_name}': {exc}",
-                        level=logging.ERROR,
-                    )
-                    raise RuntimeError(f"Error in tool handler '{tool_name}': {exc}")
-
-                if tool_spec is not None:
-                    output_dict = tool_spec.output_structure.from_json(tool_result)
-                    parsed_result = cast(T, output_dict)
-                elif self._output_structure:
-                    output_dict = self._output_structure.from_json(tool_result)
-                    parsed_result = output_dict
-                else:
-                    print(tool_result)
-                    parsed_result = cast(T, tool_result)
-
-            if isinstance(response_output, ResponseOutputMessage):
-                self.messages.add_assistant_message(response_output, metadata=kwargs)
-                self.save()
-                if hasattr(response, "output_text") and response.output_text:
-                    raw_text = response.output_text
-                    log("No tool call. Parsing output_text.")
-                    try:
-                        output_dict = json.loads(raw_text)
-                        if self._output_structure:
-                            return self._output_structure.from_json(output_dict)
-                        return output_dict
-                    except Exception:
-                        print(raw_text)
-        if parsed_result is not None:
-            return parsed_result
-        return response.output_text
+                    if hasattr(response, "output_text") and response.output_text:
+                        raw_text = response.output_text
+                        log("No tool call. Parsing output_text.")
+                        try:
+                            output_dict = json.loads(raw_text)
+                            if self._output_structure:
+                                return self._output_structure.from_json(output_dict)
+                            return output_dict
+                        except Exception:
+                            print(raw_text)
+            if parsed_result is not None:
+                return parsed_result
+            return response.output_text
+        except Exception as exc:
+            try:
+                self.save_error(exc)
+            except Exception as save_exc:
+                log(
+                    f"Failed to save error details for response {self.uuid}: {save_exc}",
+                    level=logging.ERROR,
+                    exc=save_exc,
+                )
+            log(
+                f"Error running response '{self._name}': {exc}",
+                level=logging.ERROR,
+                exc=exc,
+            )
+            raise
 
     def run_sync(
         self,
@@ -865,6 +895,36 @@ class ResponseBase(Generic[T]):
         self.messages.to_json_file(str(checked))
         log(f"Saved messages to {target}")
 
+    def save_error(self, exc: BaseException) -> Path:
+        """Persist error details to a file named with the response UUID.
+
+        Parameters
+        ----------
+        exc : BaseException
+            Exception instance to serialize.
+
+        Returns
+        -------
+        Path
+            Path to the error file written to disk.
+
+        Examples
+        --------
+        >>> try:
+        ...     response.run_sync("trigger error")
+        ... except Exception as exc:
+        ...     response.save_error(exc)
+        """
+        error_text = "".join(
+            traceback.format_exception(type(exc), exc, exc.__traceback__)
+        )
+        filename = f"{str(self.uuid).lower()}_error.txt"
+        target = self._data_path / self._name / filename
+        checked = check_filepath(filepath=target)
+        checked.write_text(error_text, encoding="utf-8")
+        log(f"Saved error details to {checked}")
+        return checked
+
     def __repr__(self) -> str:
         """Return a detailed string representation of the response session.
 
@@ -936,7 +996,19 @@ class ResponseBase(Generic[T]):
                         f"Files API cleanup: {successful}/{len(cleanup_results)} files deleted"
                     )
         except Exception as exc:
-            log(f"Error cleaning up Files API uploads: {exc}", level=logging.WARNING)
+            try:
+                self.save_error(exc)
+            except Exception as save_exc:
+                log(
+                    f"Failed to save error details for response {self.uuid}: {save_exc}",
+                    level=logging.ERROR,
+                    exc=save_exc,
+                )
+            log(
+                f"Error cleaning up Files API uploads: {exc}",
+                level=logging.WARNING,
+                exc=exc,
+            )
 
         # Always clean user vector storage if it exists
         try:
@@ -944,6 +1016,18 @@ class ResponseBase(Generic[T]):
                 self._user_vector_storage.delete()
                 log("User vector store deleted.")
         except Exception as exc:
-            log(f"Error deleting user vector store: {exc}", level=logging.WARNING)
+            try:
+                self.save_error(exc)
+            except Exception as save_exc:
+                log(
+                    f"Failed to save error details for response {self.uuid}: {save_exc}",
+                    level=logging.ERROR,
+                    exc=save_exc,
+                )
+            log(
+                f"Error deleting user vector store: {exc}",
+                level=logging.WARNING,
+                exc=exc,
+            )
         # System vector store cleanup is now handled via tool configuration
         log(f"Session {self.uuid} closed.")

openai_sdk_helpers/response/files.py

@@ -66,6 +66,12 @@ def process_files(
         2. Base64-encoded file content (ResponseInputFileContentParam)
         3. Base64-encoded image content (ResponseInputImageContentParam)
 
+    Notes
+    -----
+    Inline ``input_file`` attachments only support PDF documents. For other
+    document formats, use ``use_vector_store=True`` or convert to PDF before
+    calling this helper.
+
     Examples
     --------
     >>> from openai_sdk_helpers.response import process_files
@@ -93,6 +99,9 @@ def process_files(
         else:
             document_files.append(file_path)
 
+    if document_files and not use_vector_store:
+        _validate_inline_document_files(document_files)
+
     # Handle document files (vector store or base64)
     vector_file_refs: list[ResponseInputFileParam] = []
     base64_files: list[ResponseInputFileContentParam] = []
@@ -113,6 +122,34 @@ def process_files(
     return vector_file_refs, base64_files, image_contents
 
 
+def _validate_inline_document_files(document_files: list[str]) -> None:
+    """Validate document files for inline ``input_file`` usage.
+
+    Parameters
+    ----------
+    document_files : list[str]
+        Document file paths that will be sent as inline ``input_file``
+        attachments.
+
+    Raises
+    ------
+    ValueError
+        If any document file is not a PDF.
+    """
+    unsupported_files = [
+        file_path
+        for file_path in document_files
+        if Path(file_path).suffix.lower() != ".pdf"
+    ]
+    if unsupported_files:
+        filenames = ", ".join(Path(path).name for path in unsupported_files)
+        raise ValueError(
+            "Inline input_file attachments support PDFs only. "
+            f"Unsupported files: {filenames}. "
+            "Convert to PDF or set use_vector_store=True."
+        )
+
+
 def _upload_to_vector_store(
     response: ResponseBase[Any], document_files: list[str]
 ) -> list[ResponseInputFileParam]:
@@ -283,7 +320,7 @@ def _encode_documents_base64_batch(
                     base64_files.append(result)
                 except Exception as exc:
                     file_path = future_to_file[future]
-                    log(f"Error encoding document {file_path}: {exc}")
+                    log(f"Error encoding document {file_path}: {exc}", exc=exc)
                     raise
 
     return base64_files
@@ -385,7 +422,7 @@ def _encode_images_base64_batch(
                     image_contents.append(result)
                 except Exception as exc:
                     image_path = future_to_file[future]
-                    log(f"Error encoding image {image_path}: {exc}")
+                    log(f"Error encoding image {image_path}: {exc}", exc=exc)
                     raise
 
     return image_contents

openai_sdk_helpers/streamlit_app/app.py

@@ -32,20 +32,12 @@ from openai_sdk_helpers.utils import (
 
 # Supported file extensions for OpenAI Assistants file search and vision
 SUPPORTED_FILE_EXTENSIONS = (
-    ".csv",
-    ".docx",
     ".gif",
-    ".html",
-    ".json",
     ".jpeg",
     ".jpg",
-    ".md",
     ".pdf",
     ".png",
-    ".pptx",
-    ".txt",
     ".webp",
-    ".xlsx",
 )
 
 

openai_sdk_helpers/vector_storage/cleanup.py

@@ -73,10 +73,11 @@ def _delete_all_vector_stores() -> None:
                     log(
                         f"Failed to delete orphaned file {file.id}: {exc}",
                         level=logging.WARNING,
+                        exc=exc,
                     )
 
     except Exception as exc:
-        log(f"Error during cleanup: {exc}", level=logging.ERROR)
+        log(f"Error during cleanup: {exc}", level=logging.ERROR, exc=exc)
 
 
 def _delete_all_files() -> None:
@@ -100,4 +101,8 @@ def _delete_all_files() -> None:
             log(f"Deleting file {file.id}")
             client.files.delete(file_id=file.id)
         except Exception as exc:
-            log(f"Failed to delete file {file.id}: {exc}", level=logging.WARNING)
+            log(
+                f"Failed to delete file {file.id}: {exc}",
+                level=logging.WARNING,
+                exc=exc,
+            )

openai_sdk_helpers/vector_storage/storage.py

@@ -208,7 +208,11 @@ class VectorStorage:
                         self._existing_files[file_name] = f.id
 
             except Exception as exc:
-                log(f"Failed to load existing files: {exc}", level=logging.ERROR)
+                log(
+                    f"Failed to load existing files: {exc}",
+                    level=logging.ERROR,
+                    exc=exc,
+                )
                 self._existing_files = {}
         return self._existing_files
 
@@ -231,7 +235,11 @@ class VectorStorage:
                     result[file_name] = f.id
             return result
         except Exception as exc:
-            log(f"Failed to load existing files: {exc}", level=logging.ERROR)
+            log(
+                f"Failed to load existing files: {exc}",
+                level=logging.ERROR,
+                exc=exc,
+            )
             return {}
 
     def upload_file(
@@ -328,7 +336,11 @@ class VectorStorage:
 
             return VectorStorageFileInfo(name=file_name, id=file.id, status="success")
         except Exception as exc:
-            log(f"Error uploading {file_name}: {str(exc)}", level=logging.ERROR)
+            log(
+                f"Error uploading {file_name}: {str(exc)}",
+                level=logging.ERROR,
+                exc=exc,
+            )
             return VectorStorageFileInfo(
                 name=file_name, id="", status="error", error=str(exc)
             )
@@ -447,6 +459,7 @@ class VectorStorage:
                 log(
                     f"Warning: Could not delete file {file_id} from Files API: {file_delete_exc}",
                     level=logging.WARNING,
+                    exc=file_delete_exc,
                 )
 
             to_remove = [k for k, v in self.existing_files.items() if v == file_id]
@@ -457,7 +470,11 @@ class VectorStorage:
                 name=to_remove[0] if to_remove else "", id=file_id, status="success"
             )
         except Exception as exc:
-            log(f"Error deleting file {file_id}: {str(exc)}", level=logging.ERROR)
+            log(
+                f"Error deleting file {file_id}: {str(exc)}",
+                level=logging.ERROR,
+                exc=exc,
+            )
             return VectorStorageFileInfo(
                 name="", id=file_id, status="failed", error=str(exc)
             )
@@ -524,6 +541,7 @@ class VectorStorage:
             log(
                 f"Error deleting vector store '{self._vector_storage.name}': {str(exc)}",
                 level=logging.ERROR,
+                exc=exc,
             )
 
     def download_files(self, output_dir: str) -> VectorStorageFileStats:
@@ -551,7 +569,11 @@ class VectorStorage:
             )
             store_files = list(getattr(files, "data", files))
         except Exception as exc:
-            log(f"Failed to list files for download: {exc}", level=logging.ERROR)
+            log(
+                f"Failed to list files for download: {exc}",
+                level=logging.ERROR,
+                exc=exc,
+            )
             return VectorStorageFileStats(
                 total=0,
                 fail=1,
@@ -582,7 +604,11 @@ class VectorStorage:
                     handle.write(data)
                 stats.success += 1
             except Exception as exc:
-                log(f"Failed to download {file_id}: {exc}", level=logging.ERROR)
+                log(
+                    f"Failed to download {file_id}: {exc}",
+                    level=logging.ERROR,
+                    exc=exc,
+                )
                 stats.fail += 1
                 stats.errors.append(
                     VectorStorageFileInfo(
@@ -621,7 +647,11 @@ class VectorStorage:
             )
             return response
         except Exception as exc:
-            log(f"Error searching vector store: {str(exc)}", level=logging.ERROR)
+            log(
+                f"Error searching vector store: {str(exc)}",
+                level=logging.ERROR,
+                exc=exc,
+            )
             return None
 
     def summarize(self, query: str, *, top_k: int = 15) -> str | None:

{openai_sdk_helpers-0.5.0.dist-info → openai_sdk_helpers-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openai-sdk-helpers
-Version: 0.5.0
+Version: 0.5.2
 Summary: Composable helpers for OpenAI SDK agents, prompts, and storage
 Author: openai-sdk-helpers maintainers
 License: MIT
@@ -330,7 +330,7 @@ with ResponseBase(
 ) as response:
     # Automatic type detection - single files parameter
     # Images are sent as base64-encoded images
-    # Documents are sent as base64-encoded file data
+    # PDF documents are sent as base64-encoded file data
     result = response.run_sync(
         "Analyze these files",
         files=["photo.jpg", "document.pdf"]
@@ -356,7 +356,8 @@ with ResponseBase(
 **How It Works:**
 
 - **Images** (jpg, png, gif, etc.) are automatically sent as base64-encoded images
-- **Documents** (pdf, txt, xlsx, etc.) are sent as base64-encoded file data by default
+- **Documents** are sent as base64-encoded file data by default for PDFs only
+- **Non-PDF documents** should use `use_vector_store=True` (or be converted to PDF)
 - **Vector Stores** can optionally be used for documents when `use_vector_store=True`
 - **Batch Processing** is automatically used for multiple files (>3) for efficient encoding
 

{openai_sdk_helpers-0.5.0.dist-info → openai_sdk_helpers-0.5.2.dist-info}/RECORD

@@ -2,14 +2,14 @@ openai_sdk_helpers/__init__.py,sha256=8I469KuzrbAjhNX2A5UnYt_kSmjXqQbfHectTeUx7T
 openai_sdk_helpers/cli.py,sha256=BDc08NqWVfL4GBekxMfN5IPPB4pmN1Od9sVpKtIJRZk,8025
 openai_sdk_helpers/environment.py,sha256=mNoswzIdv37tTRhFwA2B6_Onxsm7vhfjPArfwhYuL7g,1825
 openai_sdk_helpers/errors.py,sha256=ZclLp94o08fSsFNjFn_yrX9yTjw1RE0v7A5T1hBChUc,2925
-openai_sdk_helpers/files_api.py,sha256=uMKHvGg1Od0J95Izl3AG9ofQYq8EDJXEty7zP0oKjJM,12569
-openai_sdk_helpers/logging.py,sha256=JcR0FTWht1tYdwD-bXH835pr0JV0RwHfY3poruiZGHM,795
+openai_sdk_helpers/files_api.py,sha256=Sg-k4YDsrzggvICYA7h4Ua6_vGhMpZmAeS5JtQVE2hU,12598
+openai_sdk_helpers/logging.py,sha256=djtMo_R_88JjxJeUGU_hSlYCTRv3ffoSu1ocOKrUBIw,1153
 openai_sdk_helpers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openai_sdk_helpers/settings.py,sha256=xK_u0YNKgtPrLrZrVr4F4k0CvSuYbsmkqqw9mCMdyF8,10932
 openai_sdk_helpers/tools.py,sha256=8hhcytpmDfoXV16UQbDmDVV0rhLOn8c_VjXO8XaTFLQ,19000
 openai_sdk_helpers/types.py,sha256=ejCG0rYqJhjOQvKLoNnzq-TzcKCFt69GVfi7y805NkU,1451
 openai_sdk_helpers/agent/__init__.py,sha256=SRz8WupyS89c7sYML2hkwZLkIu6zczyI9MVyDWAHK1w,1040
-openai_sdk_helpers/agent/base.py,sha256=y2LEkg4AVqNZQ_OPAn5yTy4x8lREq8tJPaUwAYTNHQY,24065
+openai_sdk_helpers/agent/base.py,sha256=8LIwi7zuYcOsXBjpsNdFTdpY8Ih-iAYXkqzLn4wkd1w,26144
 openai_sdk_helpers/agent/configuration.py,sha256=FU3xnb8-8qoezLW47WwxZg7z2AxNXRW1Svl0FMsk8kc,14244
 openai_sdk_helpers/agent/coordinator.py,sha256=lVjA0yI-GhGKlqbNR_k9GOCrUjFoZ0QoqRaafHckyME,18052
 openai_sdk_helpers/agent/runner.py,sha256=l2NPS9VA9d4RISuBfanFfKxXNYSHQ7MTjRsuzx4APls,3473
@@ -40,9 +40,9 @@ openai_sdk_helpers/prompt/vector_planner.jinja,sha256=szzuJu6ZawYWuARgQn4DykBLig
 openai_sdk_helpers/prompt/vector_search.jinja,sha256=KPEYQDRKsUesadSyQcBBiqYQEDL1NLN6BQsqw-GcKMA,249
 openai_sdk_helpers/prompt/vector_writer.jinja,sha256=q5osfexGvt1xn8ZPtBWUP36n_1HK_Ziu8dkmCZDVamc,342
 openai_sdk_helpers/response/__init__.py,sha256=YFrGpnMIfatnLWXAZgZDMvDx7Yjsqjat8W9INxKuPxY,1728
-openai_sdk_helpers/response/base.py,sha256=pZYc2YpIzg9fYP98XqVN_sTDGRpgqd-UvrBZLfUw0KQ,34791
+openai_sdk_helpers/response/base.py,sha256=jywi1EqMFSKVzAmrULn1NNqN11OYRtN8RjY3ezw4IuQ,37849
 openai_sdk_helpers/response/configuration.py,sha256=jxneKd7oj08D40ceOWETB3TeUHd7Cnz-ooQp0akI9fA,10465
-openai_sdk_helpers/response/files.py,sha256=zv5MpYZYHDBum4q9RJH_mVdnKHKOB72EB4nZwTwnlbU,13295
+openai_sdk_helpers/response/files.py,sha256=O--boEPdFGsf9pHXPuNtG0aVJG2ZzwR4L1CZDW0hBP4,14450
 openai_sdk_helpers/response/messages.py,sha256=qX3sW79rLuJEys28zyv5MovZikwGOaLevzdVN0VYMRE,10104
 openai_sdk_helpers/response/planner.py,sha256=AuNMZkd4TGnvybSJaf2iMbvfPINbusrWucWBk2uQN_g,340
 openai_sdk_helpers/response/prompter.py,sha256=TLRLmNwPcxaaB_X76BbvwXlphducPKYVbn-afTqN2Rk,344
@@ -50,7 +50,7 @@ openai_sdk_helpers/response/runner.py,sha256=3VmWY5du5iBwjVU9D0n2hexu61f561m2iTv
 openai_sdk_helpers/response/tool_call.py,sha256=Y0ub14WJyuVyj9gRdnHFH2e-ezkfhJ9nnMlkubMKdug,2938
 openai_sdk_helpers/response/vector_store.py,sha256=HClp6O_g20uklQTY7trC4age3rtDmrt3tuvrl93xIf4,3222
 openai_sdk_helpers/streamlit_app/__init__.py,sha256=3yAkl6qV71cqtT5YFZuC9Bkqit0NtffDV6jmMWpT1k4,812
-openai_sdk_helpers/streamlit_app/app.py,sha256=YbCMOOjrC4rxqQP09WcFnHnfpIYYXn-9Tn-NBRGjFJI,17502
+openai_sdk_helpers/streamlit_app/app.py,sha256=kkjtdCKVwrJ9nZWuBArm3dhvcjMESX0TMqAiF61_JLM,17402
 openai_sdk_helpers/streamlit_app/configuration.py,sha256=0KeJ4HqCNFthBHsedV6ptqHluAcTPBb5_TujFOGkIUU,16685
 openai_sdk_helpers/structure/__init__.py,sha256=JRdhEFPLDwty8tuAzCmep59RSknorZ4Dd7cyqonOi4Q,3891
 openai_sdk_helpers/structure/agent_blueprint.py,sha256=VyJWkgPNzAYKRDMeR1M4kE6qqQURnwqtrrEn0TRJf0g,9698
@@ -85,11 +85,11 @@ openai_sdk_helpers/utils/json/data_class.py,sha256=Bobc5yCZPMh093-0fiWaYNcEH7gUX
 openai_sdk_helpers/utils/json/ref.py,sha256=FqBIRWIw33Up3rFyTlLYljcuUjg43f6Nu5wX3tOXn54,2809
 openai_sdk_helpers/utils/json/utils.py,sha256=iyc25tnObqXQJWPKLZMVts932GArdKer59KuC8aQKsY,5948
 openai_sdk_helpers/vector_storage/__init__.py,sha256=L5LxO09puh9_yBB9IDTvc1CvVkARVkHqYY1KX3inB4c,975
-openai_sdk_helpers/vector_storage/cleanup.py,sha256=ImWIE-9lli-odD8qIARvmeaa0y8ZD4pYYP-kT0O3178,3552
-openai_sdk_helpers/vector_storage/storage.py,sha256=CcpATTNdeppmMfbQLnhv29hdEfE3wtAVsyKHNCrL-cI,23657
+openai_sdk_helpers/vector_storage/cleanup.py,sha256=sZ4ZSTlnjF52o9Cc8A9dTX37ZYXXDxS_fdIpoOBWvrg,3666
+openai_sdk_helpers/vector_storage/storage.py,sha256=t_ukacaXRa9EXE4-3BxsrB4Rjhu6nTu7NA9IjCJBIpQ,24259
 openai_sdk_helpers/vector_storage/types.py,sha256=jTCcOYMeOpZWvcse0z4T3MVs-RBOPC-fqWTBeQrgafU,1639
-openai_sdk_helpers-0.5.0.dist-info/METADATA,sha256=DoveMw25xYYVHQpPcj8FZjz4oEDvwPPbMALwVeU-fwI,24106
-openai_sdk_helpers-0.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-openai_sdk_helpers-0.5.0.dist-info/entry_points.txt,sha256=gEOD1ZeXe8d2OP-KzUlG-b_9D9yUZTCt-GFW3EDbIIY,63
-openai_sdk_helpers-0.5.0.dist-info/licenses/LICENSE,sha256=CUhc1NrE50bs45tcXF7OcTQBKEvkUuLqeOHgrWQ5jaA,1067
-openai_sdk_helpers-0.5.0.dist-info/RECORD,,
+openai_sdk_helpers-0.5.2.dist-info/METADATA,sha256=xpFtABEk1-jSCL63qbJ4LRzrje5jHfHXwcLSrwuQ-6g,24185
+openai_sdk_helpers-0.5.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+openai_sdk_helpers-0.5.2.dist-info/entry_points.txt,sha256=gEOD1ZeXe8d2OP-KzUlG-b_9D9yUZTCt-GFW3EDbIIY,63
+openai_sdk_helpers-0.5.2.dist-info/licenses/LICENSE,sha256=CUhc1NrE50bs45tcXF7OcTQBKEvkUuLqeOHgrWQ5jaA,1067
+openai_sdk_helpers-0.5.2.dist-info/RECORD,,