openai-sdk-helpers 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

openai_sdk_helpers/__init__.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from .environment import get_data_path, get_model
 from .utils.async_utils import run_coroutine_thread_safe, run_coroutine_with_fallback
 from .context_manager import (
     AsyncManagedResource,
@@ -61,7 +62,7 @@ from .agent import (
     SummarizerAgent,
     TranslatorAgent,
     ValidatorAgent,
-    VectorSearch,
+    VectorAgentSearch,
     WebAgentSearch,
 )
 from .response import (
@@ -103,6 +104,9 @@ from .types import (
 )
 
 __all__ = [
+    # Environment utilities
+    "get_data_path",
+    "get_model",
     # Async utilities
     "run_coroutine_thread_safe",
     "run_coroutine_with_fallback",
@@ -156,7 +160,7 @@ __all__ = [
     "SummarizerAgent",
     "TranslatorAgent",
     "ValidatorAgent",
-    "VectorSearch",
+    "VectorAgentSearch",
     "WebAgentSearch",
     "ExtendedSummaryStructure",
     "WebSearchStructure",

openai_sdk_helpers/agent/__init__.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from .base import AgentBase
-from .config import AgentConfiguration, AgentConfigurationRegistry, get_default_registry
+from .config import AgentConfiguration, AgentRegistry, get_default_registry
 from ..structure.plan.enum import AgentEnum
 from .coordination import CoordinatorAgent
 from .runner import run_sync, run_async, run_streamed
@@ -12,13 +12,13 @@ from .summarizer import SummarizerAgent
 from .translator import TranslatorAgent
 from .validation import ValidatorAgent
 from .utils import run_coroutine_agent_sync
-from .search.vector import VectorSearch
+from .search.vector import VectorAgentSearch
 from .search.web import WebAgentSearch
 
 __all__ = [
     "AgentBase",
     "AgentConfiguration",
-    "AgentConfigurationRegistry",
+    "AgentRegistry",
     "get_default_registry",
     "AgentEnum",
     "CoordinatorAgent",
@@ -32,6 +32,6 @@ __all__ = [
     "SummarizerAgent",
     "TranslatorAgent",
     "ValidatorAgent",
-    "VectorSearch",
+    "VectorAgentSearch",
     "WebAgentSearch",
 ]

openai_sdk_helpers/agent/base.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+import json
 from pathlib import Path
-from typing import Any, Dict, Optional, Protocol, cast
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Protocol, cast
 import uuid
 
 from agents import (
@@ -21,16 +22,23 @@ from jinja2 import Template
 
 from ..utils.json.data_class import DataclassJSONSerializable
 from ..structure.base import StructureBase
+from ..structure.prompt import PromptStructure
 
 from ..utils import (
     check_filepath,
     log,
 )
 
+from ..tools import tool_handler_factory
+
 from .runner import run_async, run_streamed, run_sync
 
+if TYPE_CHECKING:
+    from ..config import OpenAISettings
+    from ..response.base import ResponseBase, ToolHandler
+
 
-class AgentConfigurationLike(Protocol):
+class AgentConfigurationProtocol(Protocol):
     """Protocol describing the configuration attributes for AgentBase."""
 
     @property
@@ -181,6 +189,10 @@ class AgentBase(DataclassJSONSerializable):
         Return a streaming result for the agent execution.
     as_tool()
         Return the agent as a callable tool.
+    as_response_tool()
+        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.
     close()
         Clean up agent resources (can be overridden by subclasses).
     """
@@ -188,7 +200,7 @@ class AgentBase(DataclassJSONSerializable):
     def __init__(
         self,
         *,
-        config: AgentConfigurationLike,
+        config: AgentConfigurationProtocol,
         run_context_wrapper: Optional[RunContextWrapper[Dict[str, Any]]] = None,
         data_path: Path | str | None = None,
         prompt_dir: Optional[Path] = None,
@@ -198,7 +210,7 @@ class AgentBase(DataclassJSONSerializable):
 
         Parameters
         ----------
-        config : AgentConfigurationLike
+        config : AgentConfigurationProtocol
             Configuration describing this agent.
         run_context_wrapper : RunContextWrapper or None, default=None
             Optional wrapper providing runtime context for prompt rendering.
@@ -428,7 +440,7 @@ class AgentBase(DataclassJSONSerializable):
             "model": self.model,
         }
         if self._output_structure:
-            agent_config["output_structure"] = self._output_structure
+            agent_config["output_type"] = self._output_structure
         if self._tools:
             agent_config["tools"] = self._tools
         if self._model_settings:
@@ -575,6 +587,156 @@ class AgentBase(DataclassJSONSerializable):
         )
         return tool_obj
 
+    def as_response_tool(
+        self,
+        *,
+        tool_name: str | None = None,
+        tool_description: str | None = None,
+    ) -> tuple[dict[str, Callable[..., Any]], dict[str, Any]]:
+        """Return response tool handler and definition for Responses API use.
+
+        The returned handler serializes tool output as JSON using
+        ``tool_handler_factory`` so downstream response flows can rely on a
+        consistent payload format.
+
+        Parameters
+        ----------
+        tool_name : str or None, default=None
+            Optional override for the tool name. When None, uses the agent name.
+        tool_description : str or None, default=None
+            Optional override for the tool description. When None, uses the
+            agent description.
+
+        Returns
+        -------
+        tuple[dict[str, Callable[..., Any]], dict[str, Any]]
+            Tool handler mapping and tool definition for Responses API usage.
+
+        Examples
+        --------
+        >>> tool_handler, tool_definition = agent.as_response_tool()
+        >>> response = ResponseBase(
+        ...     name="agent_tool",
+        ...     instructions="Use the agent tool when needed.",
+        ...     tools=[tool_definition],
+        ...     output_structure=None,
+        ...     tool_handlers=tool_handler,
+        ...     openai_settings=settings,
+        ... )
+        >>> response.run_sync("Invoke the agent tool")  # doctest: +SKIP
+        """
+
+        def _run_agent(**kwargs: Any) -> Any:
+            prompt = kwargs.get("prompt")
+            if prompt is None:
+                if len(kwargs) == 1:
+                    prompt = next(iter(kwargs.values()))
+                else:
+                    prompt = json.dumps(kwargs)
+            return self.run_sync(str(prompt))
+
+        name = tool_name or self.name
+        description = tool_description or self.description
+        input_model = self._input_structure or PromptStructure
+        tool_handler = {name: tool_handler_factory(_run_agent, input_model=input_model)}
+        tool_definition = {
+            "type": "function",
+            "name": name,
+            "description": description,
+            "strict": True,
+            "additionalProperties": False,
+            "parameters": self._build_response_parameters(),
+        }
+        return tool_handler, tool_definition
+
+    def build_response(
+        self,
+        *,
+        openai_settings: OpenAISettings,
+        data_path: Path | str | None = None,
+        tool_handlers: dict[str, ToolHandler] | None = None,
+        system_vector_store: list[str] | None = None,
+    ) -> ResponseBase[StructureBase]:
+        """Build a ResponseBase instance from this agent configuration.
+
+        Parameters
+        ----------
+        openai_settings : OpenAISettings
+            Authentication and model settings applied to the generated response.
+        data_path : Path, str, or None, default None
+            Optional path for storing response artifacts. When None, the
+            response uses the default data directory.
+        tool_handlers : dict[str, ToolHandler] or None, default None
+            Optional mapping of tool names to handler callables.
+        system_vector_store : list[str] or None, default None
+            Optional list of vector store names to attach as system context.
+
+        Returns
+        -------
+        ResponseBase[StructureBase]
+            ResponseBase instance configured with this agent's settings.
+
+        Examples
+        --------
+        >>> from openai_sdk_helpers import OpenAISettings
+        >>> response = agent.build_response(openai_settings=OpenAISettings.from_env())
+        """
+        from ..response.base import ResponseBase, ToolHandler
+        from ..config import OpenAISettings
+
+        if not isinstance(openai_settings, OpenAISettings):
+            raise TypeError("openai_settings must be an OpenAISettings instance")
+
+        tools = self._normalize_response_tools(self.tools)
+
+        return ResponseBase(
+            name=self.name,
+            instructions=self.instructions_text,
+            tools=tools,
+            output_structure=self.output_structure,
+            system_vector_store=system_vector_store,
+            data_path=data_path,
+            tool_handlers=tool_handlers,
+            openai_settings=openai_settings,
+        )
+
+    def _build_response_parameters(self) -> dict[str, Any]:
+        """Build the Responses API parameter schema for this agent tool.
+
+        Returns
+        -------
+        dict[str, Any]
+            JSON schema describing tool input parameters.
+        """
+        if self._input_structure is not None:
+            return self._input_structure.get_schema()
+        return {
+            "type": "object",
+            "properties": {
+                "prompt": {"type": "string", "description": "Prompt text to run."}
+            },
+            "required": ["prompt"],
+            "additionalProperties": False,
+        }
+
+    @staticmethod
+    def _normalize_response_tools(tools: Optional[list]) -> Optional[list]:
+        """Normalize tool definitions for the Responses API."""
+        if not tools:
+            return tools
+
+        normalized: list[Any] = []
+        for tool in tools:
+            if hasattr(tool, "to_dict") and callable(tool.to_dict):
+                normalized.append(tool.to_dict())
+            elif hasattr(tool, "to_openai_tool") and callable(tool.to_openai_tool):
+                normalized.append(tool.to_openai_tool())
+            elif hasattr(tool, "schema"):
+                normalized.append(tool.schema)
+            else:
+                normalized.append(tool)
+        return normalized
+
     def __enter__(self) -> AgentBase:
         """Enter the context manager for resource management.
 
@@ -651,4 +813,4 @@ class AgentBase(DataclassJSONSerializable):
         log(f"Saved messages to {target}")
 
 
-__all__ = ["AgentConfigurationLike", "AgentBase"]
+__all__ = ["AgentConfigurationProtocol", "AgentBase"]

openai_sdk_helpers/agent/config.py

@@ -10,20 +10,20 @@ from agents import Agent, Handoff, InputGuardrail, OutputGuardrail, Session
 from agents.model_settings import ModelSettings
 
 from ..utils.json.data_class import DataclassJSONSerializable
-from ..utils.registry import BaseRegistry
+from ..utils.registry import RegistryBase
 from ..utils.instructions import resolve_instructions_from_path
 from ..structure.base import StructureBase
 
 
-class AgentConfigurationRegistry(BaseRegistry["AgentConfiguration"]):
+class AgentRegistry(RegistryBase["AgentConfiguration"]):
     """Registry for managing AgentConfiguration instances.
 
-    Inherits from BaseRegistry to provide centralized storage and retrieval
+    Inherits from RegistryBase to provide centralized storage and retrieval
     of agent configurations, enabling reusable agent specs across the application.
 
     Examples
     --------
-    >>> registry = AgentConfigurationRegistry()
+    >>> registry = AgentRegistry()
     >>> config = AgentConfiguration(
     ...     name="test_agent",
     ...     model="gpt-4o-mini",
@@ -65,7 +65,7 @@ class AgentConfigurationRegistry(BaseRegistry["AgentConfiguration"]):
 
         Examples
         --------
-        >>> registry = AgentConfigurationRegistry()
+        >>> registry = AgentRegistry()
         >>> count = registry.load_from_directory("./agents")
         >>> print(f"Loaded {count} configurations")
         """
@@ -74,12 +74,12 @@ class AgentConfigurationRegistry(BaseRegistry["AgentConfiguration"]):
         return super().load_from_directory(path, config_class=config_class)
 
 
-def get_default_registry() -> AgentConfigurationRegistry:
+def get_default_registry() -> AgentRegistry:
     """Return the global default registry instance.
 
     Returns
     -------
-    AgentConfigurationRegistry
+    AgentRegistry
         Singleton registry for application-wide configuration storage.
 
     Examples
@@ -187,9 +187,8 @@ class AgentConfiguration(DataclassJSONSerializable):
     input_guardrails: Optional[list[InputGuardrail]] = None
     output_guardrails: Optional[list[OutputGuardrail]] = None
     session: Optional[Session] = None
-    _instructions_cache: Optional[str] = field(
-        default=None, init=False, repr=False, compare=False
-    )
+    add_output_instructions: bool = False
+    add_web_search_tool: bool = False
 
     def __post_init__(self) -> None:
         """Validate configuration invariants after initialization.
@@ -258,11 +257,16 @@ class AgentConfiguration(DataclassJSONSerializable):
         str
             Plain-text instructions, loading template files when necessary.
         """
-        cached = self._instructions_cache
-        if cached is None:
-            cached = self._resolve_instructions()
-            object.__setattr__(self, "_instructions_cache", cached)
-        return cached
+        resolved_instructions: str = resolve_instructions_from_path(self.instructions)
+        output_instructions = ""
+        if self.output_structure is not None and self.add_output_instructions:
+            output_instructions = self.output_structure.get_prompt(
+                add_enum_values=False
+            )
+            if output_instructions:
+                return f"{resolved_instructions}\n{output_instructions}"
+
+        return resolved_instructions
 
     def _resolve_instructions(self) -> str:
         """Resolve instructions from string or file path."""
@@ -361,69 +365,40 @@ class AgentConfiguration(DataclassJSONSerializable):
 
         return replace(self, **changes)
 
-    def to_json(self) -> dict[str, Any]:
-        """Return a JSON-compatible dict representation.
-
-        Returns
-        -------
-        dict[str, Any]
-            Serialized configuration data without cached fields.
-        """
-        data = DataclassJSONSerializable.to_json(self)
-        data.pop("_instructions_cache", None)
-        return data
-
-    @classmethod
-    def from_json(cls, data: dict[str, Any]) -> AgentConfiguration:
-        """Create an AgentConfiguration from JSON data.
+    def to_response_config(self) -> Any:
+        """Convert this AgentConfiguration to a ResponseConfiguration.
 
-        Overrides the default JSONSerializable.from_json to properly handle
-        the instructions field, converting string paths that look like file
-        paths back to Path objects for proper file loading.
-
-        Parameters
-        ----------
-        data : dict[str, Any]
-            Dictionary containing the configuration data.
+        This is a convenience method for creating a ResponseConfiguration
+        instance using the relevant fields from this agent configuration.
 
         Returns
         -------
-        AgentConfiguration
-            New configuration instance.
-
-        Notes
-        -----
-        This method attempts to preserve the original type of the instructions
-        field. If instructions is a string that represents an existing file path,
-        it will be converted to a Path object to ensure proper file loading
-        behavior is maintained across JSON round-trips.
+        ResponseConfiguration
+            New response configuration instance.
+
+        Examples
+        --------
+        >>> agent_config = AgentConfiguration(
+        ...     name="responder",
+        ...     model="gpt-4o-mini",
+        ...     instructions="Respond to user queries"
+        ... )
+        >>> response_config = agent_config.to_response_config()
+        >>> response_config.name
+        'responder'
         """
-        # Make a copy to avoid modifying the input
-        data = data.copy()
-        data.pop("_instructions_cache", None)
-
-        # Handle instructions field: if it's a string path to an existing file,
-        # convert it back to Path for proper file loading
-        if "instructions" in data and data["instructions"] is not None:
-            instructions_value = data["instructions"]
-            if isinstance(instructions_value, str):
-                # Check if it looks like a file path and the file exists
-                # This preserves the intended behavior for file-based instructions
-                try:
-                    potential_path = Path(instructions_value)
-                    # Only convert to Path if it's an existing file
-                    # This way, plain text instructions stay as strings
-                    if potential_path.exists() and potential_path.is_file():
-                        data["instructions"] = potential_path
-                except (OSError, ValueError):
-                    # If path parsing fails, keep it as a string (likely plain text)
-                    pass
-
-        # Use the parent class method for the rest
-        return super(AgentConfiguration, cls).from_json(data)
+        from ..response.config import ResponseConfiguration
+
+        return ResponseConfiguration(
+            name=self.name,
+            instructions=self.instructions,
+            input_structure=self.input_structure,
+            output_structure=self.output_structure,
+            tools=self.tools,
+        )
 
 
 # Global default registry instance
-_default_registry = AgentConfigurationRegistry()
+_default_registry = AgentRegistry()
 
-__all__ = ["AgentConfiguration", "AgentConfigurationRegistry", "get_default_registry"]
+__all__ = ["AgentConfiguration", "AgentRegistry", "get_default_registry"]

openai_sdk_helpers/agent/search/__init__.py

@@ -10,10 +10,10 @@ from .web import (
 )
 from .vector import (
     MAX_CONCURRENT_SEARCHES as VECTOR_MAX_CONCURRENT_SEARCHES,
-    VectorSearchPlanner,
+    VectorAgentPlanner,
     VectorSearchTool,
     VectorSearchWriter,
-    VectorSearch,
+    VectorAgentSearch,
 )
 
 __all__ = [
@@ -26,8 +26,8 @@ __all__ = [
     "WebAgentWriter",
     "WebAgentSearch",
     "VECTOR_MAX_CONCURRENT_SEARCHES",
-    "VectorSearchPlanner",
+    "VectorAgentPlanner",
     "VectorSearchTool",
     "VectorSearchWriter",
-    "VectorSearch",
+    "VectorAgentSearch",
 ]

openai_sdk_helpers/agent/search/vector.py

@@ -7,6 +7,7 @@ from typing import Any, Callable, Dict, List, Optional
 
 from agents import custom_span, gen_trace_id, trace
 
+from ...structure.prompt import PromptStructure
 from ...structure.vector_search import (
     VectorSearchItemStructure,
     VectorSearchItemResultStructure,
@@ -15,6 +16,7 @@ from ...structure.vector_search import (
     VectorSearchPlanStructure,
     VectorSearchReportStructure,
 )
+from ...tools import tool_handler_factory
 from ...vector_storage import VectorStorage
 from ..config import AgentConfiguration
 from ..utils import run_coroutine_agent_sync
@@ -23,7 +25,7 @@ from .base import SearchPlanner, SearchToolAgent, SearchWriter
 MAX_CONCURRENT_SEARCHES = 10
 
 
-class VectorSearchPlanner(SearchPlanner[VectorSearchPlanStructure]):
+class VectorAgentPlanner(SearchPlanner[VectorSearchPlanStructure]):
     """Plan vector searches to satisfy a user query.
 
     Parameters
@@ -241,7 +243,7 @@ class VectorSearchWriter(SearchWriter[VectorSearchReportStructure]):
         )
 
 
-class VectorSearch:
+class VectorAgentSearch:
     """Manage the complete vector search workflow.
 
     This high-level agent orchestrates a multi-step research process that plans
@@ -292,6 +294,8 @@ class VectorSearch:
         Execute the research workflow asynchronously.
     run_agent_sync(search_query)
         Execute the research workflow synchronously.
+    as_response_tool(vector_store_name, tool_name, tool_description)
+        Build a Responses API tool definition and handler.
     run_vector_agent(search_query)
         Convenience asynchronous entry point for the workflow.
     run_vector_agent_sync(search_query)
@@ -306,9 +310,9 @@ class VectorSearch:
     def __init__(
         self,
         *,
+        vector_store_name: str,
         prompt_dir: Optional[Path] = None,
         default_model: Optional[str] = None,
-        vector_store_name: Optional[str] = None,
         max_concurrent_searches: int = MAX_CONCURRENT_SEARCHES,
         vector_storage: Optional[VectorStorage] = None,
         vector_storage_factory: Optional[Callable[[str], VectorStorage]] = None,
@@ -336,7 +340,7 @@ class VectorSearch:
         """
         trace_id = gen_trace_id()
         with trace("VectorSearch trace", trace_id=trace_id):
-            planner = VectorSearchPlanner(
+            planner = VectorAgentPlanner(
                 prompt_dir=self._prompt_dir, default_model=self._default_model
             )
             tool = VectorSearchTool(
@@ -383,45 +387,53 @@ class VectorSearch:
         """
         return run_coroutine_agent_sync(self.run_agent(search_query))
 
-    @staticmethod
-    async def run_vector_agent(search_query: str) -> VectorSearchStructure:
-        """Return a research report for the given query using ``VectorSearch``.
+    def as_response_tool(
+        self,
+        *,
+        tool_name: str = "vector_search",
+        tool_description: str = "Run the vector search workflow.",
+    ) -> tuple[dict[str, Callable[..., Any]], dict[str, Any]]:
+        """Return a Responses API tool handler and definition.
 
         Parameters
         ----------
-        search_query : str
-            User's research query.
+        vector_store_name : str
+            Name of the vector store to use for the response tool.
+        tool_name : str, default="vector_search"
+            Name to use for the response tool.
+        tool_description : str, default="Run the vector search workflow."
+            Description for the response tool.
 
         Returns
         -------
-        VectorSearchStructure
-            Completed research output.
+        tuple[dict[str, Callable[..., Any]], dict[str, Any]]
+            Tool handler mapping and tool definition for Responses API usage.
         """
-        return await VectorSearch().run_agent(search_query=search_query)
+        search = VectorAgentSearch(
+            prompt_dir=self._prompt_dir,
+            default_model=self._default_model,
+            vector_store_name=self._vector_store_name,
+            max_concurrent_searches=self._max_concurrent_searches,
+            vector_storage=self._vector_storage,
+            vector_storage_factory=self._vector_storage_factory,
+        )
 
-    @staticmethod
-    def run_vector_agent_sync(search_query: str) -> VectorSearchStructure:
-        """Run :meth:`run_vector_agent` synchronously for ``search_query``.
+        def _run_search(prompt: str) -> VectorSearchStructure:
+            return run_coroutine_agent_sync(search.run_agent(search_query=prompt))
 
-        Parameters
-        ----------
-        search_query : str
-            User's research query.
-
-        Returns
-        -------
-        VectorSearchStructure
-            Completed research output.
-        """
-        return run_coroutine_agent_sync(
-            VectorSearch.run_vector_agent(search_query=search_query)
+        tool_handler = {
+            tool_name: tool_handler_factory(_run_search, input_model=PromptStructure)
+        }
+        tool_definition = PromptStructure.response_tool_definition(
+            tool_name, tool_description=tool_description
         )
+        return tool_handler, tool_definition
 
 
 __all__ = [
     "MAX_CONCURRENT_SEARCHES",
-    "VectorSearchPlanner",
+    "VectorAgentPlanner",
     "VectorSearchTool",
     "VectorSearchWriter",
-    "VectorSearch",
+    "VectorAgentSearch",
 ]

openai_sdk_helpers/agent/search/web.py

@@ -3,12 +3,13 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from agents import custom_span, gen_trace_id, trace
 from agents.model_settings import ModelSettings
 from agents.tool import WebSearchTool
 
+from ...structure.prompt import PromptStructure
 from ...structure.web_search import (
     WebSearchItemStructure,
     WebSearchItemResultStructure,
@@ -16,6 +17,7 @@ from ...structure.web_search import (
     WebSearchPlanStructure,
     WebSearchReportStructure,
 )
+from ...tools import tool_handler_factory
 from ..config import AgentConfiguration
 from ..utils import run_coroutine_agent_sync
 from .base import SearchPlanner, SearchToolAgent, SearchWriter
@@ -242,6 +244,8 @@ class WebAgentSearch:
         Execute the research workflow asynchronously.
     run_agent_sync(search_query)
         Execute the research workflow synchronously.
+    as_response_tool(tool_name, tool_description)
+        Build a Responses API tool definition and handler.
     run_web_agent_async(search_query)
         Convenience asynchronous entry point for the workflow.
     run_web_agent_sync(search_query)
@@ -301,7 +305,7 @@ class WebAgentSearch:
         )
 
     def run_agent_sync(self, search_query: str) -> WebSearchStructure:
-        """Run :meth:`run_agent_async` synchronously for ``search_query``.
+        """Execute the entire research workflow for ``search_query`` synchronously.
 
         Parameters
         ----------
@@ -312,41 +316,41 @@ class WebAgentSearch:
         -------
         WebSearchStructure
             Completed research output.
+
         """
         return run_coroutine_agent_sync(self.run_agent_async(search_query))
 
-    async def run_web_agent_async(self, search_query: str) -> WebSearchStructure:
-        """Return a research report for the given query using ``WebAgentSearch``.
+    def as_response_tool(
+        self,
+        *,
+        tool_name: str = "web_search",
+        tool_description: str = "Run the web search workflow.",
+    ) -> tuple[dict[str, Callable[..., Any]], dict[str, Any]]:
+        """Return a Responses API tool handler and definition.
 
         Parameters
         ----------
-        search_query : str
-            User's research query.
+        tool_name : str, default="web_search"
+            Name to use for the response tool.
+        tool_description : str, default="Run the web search workflow."
+            Description for the response tool.
 
         Returns
         -------
-        WebSearchStructure
-            Completed research output.
+        tuple[dict[str, Callable[..., Any]], dict[str, Any]]
+            Tool handler mapping and tool definition for Responses API usage.
         """
-        return await self.run_agent_async(search_query=search_query)
 
-    @staticmethod
-    def run_web_agent_sync(search_query: str) -> WebSearchStructure:
-        """Run :meth:`run_web_agent_async` synchronously for ``search_query``.
+        def _run_search(prompt: str) -> WebSearchStructure:
+            return run_coroutine_agent_sync(self.run_agent_async(search_query=prompt))
 
-        Parameters
-        ----------
-        search_query : str
-            User's research query.
-
-        Returns
-        -------
-        WebSearchStructure
-            Completed research output.
-        """
-        return run_coroutine_agent_sync(
-            WebAgentSearch().run_web_agent_async(search_query=search_query)
+        tool_handler = {
+            tool_name: tool_handler_factory(_run_search, input_model=PromptStructure)
+        }
+        tool_definition = PromptStructure.response_tool_definition(
+            tool_name, tool_description=tool_description
         )
+        return tool_handler, tool_definition
 
 
 __all__ = [

openai_sdk_helpers/environment.py

@@ -18,10 +18,15 @@ get_data_path(name)
 
 from __future__ import annotations
 
+import os
+import os
 from pathlib import Path
+from dotenv import load_dotenv
+
 
 from openai_sdk_helpers.utils import ensure_directory
 
+load_dotenv()
 DATETIME_FMT = "%Y%m%d_%H%M%S"
 DEFAULT_MODEL = "gpt-4o-mini"
 
@@ -54,3 +59,20 @@ def get_data_path(name: str) -> Path:
     base = Path(__file__).parent.parent.parent / "data"
     path = base / name
     return ensure_directory(path)
+
+
+def get_model() -> str:
+    """Return the default model identifier.
+
+    Returns
+    -------
+    str
+        Default OpenAI model identifier.
+
+    Examples
+    --------
+    >>> from openai_sdk_helpers.environment import _get_default_model
+    >>> _get_default_model()
+    'gpt-4o-mini'
+    """
+    return os.getenv("DEFAULT_MODEL", DEFAULT_MODEL)

openai_sdk_helpers/response/config.py

@@ -10,17 +10,17 @@ from ..config import OpenAISettings
 from ..structure.base import StructureBase
 from ..response.base import ResponseBase, ToolHandler
 from ..utils.json.data_class import DataclassJSONSerializable
-from ..utils.registry import BaseRegistry
+from ..utils.registry import RegistryBase
 from ..utils.instructions import resolve_instructions_from_path
 
 TIn = TypeVar("TIn", bound="StructureBase")
 TOut = TypeVar("TOut", bound="StructureBase")
 
 
-class ResponseRegistry(BaseRegistry["ResponseConfiguration"]):
+class ResponseRegistry(RegistryBase["ResponseConfiguration"]):
     """Registry for managing ResponseConfiguration instances.
 
-    Inherits from BaseRegistry to provide centralized storage and retrieval
+    Inherits from RegistryBase to provide centralized storage and retrieval
     of response configurations, enabling reusable response specs across the application.
 
     Examples
@@ -108,8 +108,6 @@ class ResponseConfiguration(DataclassJSONSerializable, Generic[TIn, TOut]):
     -------
     __post_init__()
         Validate configuration invariants and enforce StructureBase subclassing.
-    instructions_text
-        Return the resolved instruction content as a string.
     to_json()
         Return a JSON-compatible dict representation (inherited from JSONSerializable).
     to_json_file(filepath)
@@ -137,7 +135,8 @@ class ResponseConfiguration(DataclassJSONSerializable, Generic[TIn, TOut]):
     input_structure: Optional[Type[TIn]]
     output_structure: Optional[Type[TOut]]
     system_vector_store: Optional[list[str]] = None
-    add_output_instructions: bool = True
+    add_output_instructions: bool = False
+    add_web_search_tool: bool = False
 
     def __post_init__(self) -> None:
         """
@@ -185,7 +184,7 @@ class ResponseConfiguration(DataclassJSONSerializable, Generic[TIn, TOut]):
             raise TypeError("Configuration.tools must be a Sequence or None")
 
     @property
-    def instructions_text(self) -> str:
+    def get_resolved_instructions(self) -> str:
         """Return the resolved instruction text.
 
         Returns
@@ -204,6 +203,20 @@ class ResponseConfiguration(DataclassJSONSerializable, Generic[TIn, TOut]):
 
         return resolved_instructions
 
+    @property
+    def get_resolved_tools(self) -> list:
+        """Return the complete list of tools, including optional web search tool.
+
+        Returns
+        -------
+        list
+            List of tool definitions, including web search tool if enabled.
+        """
+        tools = self.tools or []
+        if self.add_web_search_tool:
+            tools = tools + [{"type": "web_search"}]
+        return tools
+
     def gen_response(
         self,
         *,
@@ -229,8 +242,8 @@ class ResponseConfiguration(DataclassJSONSerializable, Generic[TIn, TOut]):
         """
         return ResponseBase[TOut](
             name=self.name,
-            instructions=self.instructions_text,
-            tools=self.tools,
+            instructions=self.get_resolved_instructions,
+            tools=self.get_resolved_tools,
             output_structure=self.output_structure,
             system_vector_store=self.system_vector_store,
             data_path=data_path,

openai_sdk_helpers/response/planner.py

@@ -0,0 +1,12 @@
+"""Planner response configuration."""
+
+from ..structure.plan.plan import PlanStructure
+from .config import ResponseConfiguration
+
+PLANNER = ResponseConfiguration(
+    name="planner",
+    instructions="Generates structured prompts based on user input.",
+    tools=None,
+    input_structure=None,
+    output_structure=PlanStructure,
+)

openai_sdk_helpers/response/prompter.py

@@ -0,0 +1,12 @@
+"""Prompter response configuration."""
+
+from .config import ResponseConfiguration
+from ..structure.prompt import PromptStructure
+
+PROMPTER = ResponseConfiguration(
+    name="prompter",
+    instructions="Generates structured prompts based on user input.",
+    tools=None,
+    input_structure=None,
+    output_structure=PromptStructure,
+)

openai_sdk_helpers/streamlit_app/__init__.py

@@ -8,23 +8,23 @@ Classes
 -------
 StreamlitAppConfig
     Validated configuration for Streamlit chat applications.
+StreamlitAppRegistry
+    Registry for storing Streamlit app configurations.
 
 Functions
 ---------
-load_app_config
-    Load and validate configuration from a Python module.
 _load_configuration
     Load configuration with user-friendly error handling for Streamlit UI.
 """
 
 from .config import (
     StreamlitAppConfig,
+    StreamlitAppRegistry,
     _load_configuration,
-    load_app_config,
 )
 
 __all__ = [
     "StreamlitAppConfig",
+    "StreamlitAppRegistry",
     "_load_configuration",
-    "load_app_config",
 ]

openai_sdk_helpers/streamlit_app/config.py

@@ -15,7 +15,7 @@ from pydantic import ConfigDict, Field, field_validator, model_validator
 
 from openai_sdk_helpers.response.base import ResponseBase
 from openai_sdk_helpers.structure.base import StructureBase
-from openai_sdk_helpers.utils import ensure_list
+from openai_sdk_helpers.utils import RegistryBase, ensure_list
 from ..utils.json import BaseModelJSONSerializable
 
 
@@ -29,6 +29,8 @@ class StreamlitAppConfig(BaseModelJSONSerializable):
 
     Attributes
     ----------
+    name : str
+        Unique configuration identifier. Default is ``"streamlit_app"``.
     response : ResponseBase, type[ResponseBase], Callable, or None
         Response handler as an instance, class, or callable factory.
     display_title : str
@@ -48,8 +50,6 @@ class StreamlitAppConfig(BaseModelJSONSerializable):
         Return configured system vector stores as a list.
     create_response()
         Instantiate and return the configured ResponseBase.
-    load_app_config(config_path)
-        Load, validate, and return configuration from a Python module.
 
     Examples
     --------
@@ -63,6 +63,10 @@ class StreamlitAppConfig(BaseModelJSONSerializable):
 
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
 
+    name: str = Field(
+        default="streamlit_app",
+        description="Unique configuration identifier used for registry lookup.",
+    )
     response: ResponseBase[StructureBase] | type[ResponseBase] | Callable | None = (
         Field(
             default=None,
@@ -225,6 +229,39 @@ class StreamlitAppConfig(BaseModelJSONSerializable):
         """
         return _instantiate_response(self.response)
 
+
+class StreamlitAppRegistry(RegistryBase[StreamlitAppConfig]):
+    """Registry for managing StreamlitAppConfig instances.
+
+    Inherits from RegistryBase to provide centralized storage and retrieval
+    of Streamlit app configurations, enabling reuse across applications.
+
+    Methods
+    -------
+    register(config)
+        Add a configuration to the registry.
+    get(name)
+        Retrieve a configuration by name.
+    list_names()
+        Return all registered configuration names.
+    clear()
+        Remove all registered configurations.
+    save_to_directory(path)
+        Export all registered configurations to JSON files.
+    load_from_directory(path)
+        Load configurations from JSON files in a directory.
+    load_app_config(config_path)
+        Load, validate, and return configuration from a Python module.
+
+    Examples
+    --------
+    >>> registry = StreamlitAppRegistry()
+    >>> config = StreamlitAppConfig(response=MyResponse)
+    >>> registry.register(config)
+    >>> registry.get(config.name)
+    StreamlitAppConfig(...)
+    """
+
     @staticmethod
     def load_app_config(
         config_path: Path,
@@ -258,7 +295,7 @@ class StreamlitAppConfig(BaseModelJSONSerializable):
         Examples
         --------
         >>> from pathlib import Path
-        >>> config = StreamlitAppConfig.load_app_config(
+        >>> config = StreamlitAppRegistry.load_app_config(
         ...     Path("./my_config.py")
         ... )
         """
@@ -433,36 +470,10 @@ def _config_from_mapping(raw_config: dict) -> StreamlitAppConfig:
     return StreamlitAppConfig(**config_kwargs)
 
 
-def load_app_config(
-    config_path: Path,
-) -> StreamlitAppConfig:
-    """Load and validate Streamlit configuration from a Python module.
-
-    Convenience function that proxies to StreamlitAppConfig.load_app_config
-    for backward compatibility.
-
-    Parameters
-    ----------
-    config_path : Path
-        Filesystem path to the configuration module.
-
-    Returns
-    -------
-    StreamlitAppConfig
-        Validated configuration loaded from the module.
-
-    Examples
-    --------
-    >>> from pathlib import Path
-    >>> config = load_app_config(Path("./my_config.py"))
-    """
-    return StreamlitAppConfig.load_app_config(config_path=config_path)
-
-
 def _load_configuration(config_path: Path) -> StreamlitAppConfig:
     """Load configuration with user-friendly error handling for Streamlit.
 
-    Wraps StreamlitAppConfig.load_app_config with exception handling that
+    Wraps StreamlitAppRegistry.load_app_config with exception handling that
     displays errors in the Streamlit UI and halts execution gracefully.
 
     Parameters
@@ -487,7 +498,7 @@ def _load_configuration(config_path: Path) -> StreamlitAppConfig:
     than raising exceptions that crash the app.
     """
     try:
-        return StreamlitAppConfig.load_app_config(config_path=config_path)
+        return StreamlitAppRegistry.load_app_config(config_path=config_path)
     except Exception as exc:  # pragma: no cover - surfaced in UI
         import streamlit as st  # type: ignore[import-not-found]
 
@@ -498,6 +509,6 @@ def _load_configuration(config_path: Path) -> StreamlitAppConfig:
 
 __all__ = [
     "StreamlitAppConfig",
-    "load_app_config",
+    "StreamlitAppRegistry",
     "_load_configuration",
 ]

openai_sdk_helpers/streamlit_app/streamlit_web_search.py

@@ -46,7 +46,7 @@ class StreamlitWebSearch(ResponseBase[WebSearchStructure]):
 async def perform_search(tool) -> str:
     """Perform a web search and return structured results."""
     structured_data = PromptStructure.from_tool_arguments(tool.arguments)
-    web_result = await WebAgentSearch(default_model=DEFAULT_MODEL).run_web_agent_async(
+    web_result = await WebAgentSearch(default_model=DEFAULT_MODEL).run_agent_async(
         structured_data.prompt
     )
     payload = coerce_jsonable(web_result)

openai_sdk_helpers/utils/__init__.py

@@ -55,7 +55,7 @@ from .json import (
     get_module_qualname,
     to_jsonable,
 )
-from .registry import BaseRegistry
+from .registry import RegistryBase
 
 from .path_utils import check_filepath, ensure_directory
 from openai_sdk_helpers.logging_config import log
@@ -135,5 +135,5 @@ __all__ = [
     "create_file_data_url",
     "is_image_file",
     # Registry
-    "BaseRegistry",
+    "RegistryBase",
 ]

openai_sdk_helpers/utils/json/ref.py

@@ -32,6 +32,7 @@ def get_module_qualname(obj: Any) -> tuple[str, str] | None:
     ...     pass
     >>> get_module_qualname(MyClass)
     ('__main__', 'MyClass')
+
     """
     module = getattr(obj, "__module__", None)
     qualname = getattr(obj, "__qualname__", None)
@@ -59,6 +60,7 @@ def encode_module_qualname(obj: Any) -> dict[str, Any] | None:
     ...     pass
     >>> encode_module_qualname(MyClass)
     {'module': '__main__', 'qualname': 'MyClass'}
+
     """
     result = get_module_qualname(obj)
     if result is None:
@@ -85,6 +87,7 @@ def decode_module_qualname(ref: dict[str, Any]) -> Any | None:
     >>> ref = {'module': 'pathlib', 'qualname': 'Path'}
     >>> decode_module_qualname(ref)
     <class 'pathlib.Path'>
+
     """
     if not isinstance(ref, dict):
         return None

openai_sdk_helpers/utils/registry.py

@@ -4,15 +4,42 @@ from __future__ import annotations
 
 import warnings
 from pathlib import Path
-from typing import Generic, TypeVar
+from typing import Generic, Protocol, TypeVar
+from typing_extensions import Self
 
-from ..utils.json.data_class import DataclassJSONSerializable
 from .path_utils import ensure_directory
 
-T = TypeVar("T", bound=DataclassJSONSerializable)
 
+class RegistrySerializable(Protocol):
+    """Protocol describing serializable registry entries.
 
-class BaseRegistry(Generic[T]):
+    Methods
+    -------
+    to_json_file(filepath)
+        Write the instance to a JSON file path.
+    from_json_file(filepath)
+        Load an instance from a JSON file path.
+    """
+
+    @property
+    def name(self) -> str:
+        """Return the configuration name."""
+        ...
+
+    def to_json_file(self, filepath: Path | str) -> str:
+        """Write serialized JSON data to a file path."""
+        ...
+
+    @classmethod
+    def from_json_file(cls, filepath: Path | str) -> Self:
+        """Load an instance from a JSON file."""
+        ...
+
+
+T = TypeVar("T", bound=RegistrySerializable)
+
+
+class RegistryBase(Generic[T]):
     """Base registry for managing configuration instances.
 
     Provides centralized storage and retrieval of configurations,

{openai_sdk_helpers-0.4.0.dist-info → openai_sdk_helpers-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openai-sdk-helpers
-Version: 0.4.0
+Version: 0.4.2
 Summary: Composable helpers for OpenAI SDK agents, prompts, and storage
 Author: openai-sdk-helpers maintainers
 License: MIT

{openai_sdk_helpers-0.4.0.dist-info → openai_sdk_helpers-0.4.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
-openai_sdk_helpers/__init__.py,sha256=ZvcdJWHP7oMRxSGemxgO7CIpF0dc6oBTh4oftZAYv3c,4640
+openai_sdk_helpers/__init__.py,sha256=19MEuQFgMqr6YqEc0QdmNe5YTg5JJVVCIisrYLFbqGk,4766
 openai_sdk_helpers/cli.py,sha256=YnQz-IcAqcBdh8eCCxVYa7NHDuHgHaU-PJ4FWPvkz58,8278
 openai_sdk_helpers/config.py,sha256=xK_u0YNKgtPrLrZrVr4F4k0CvSuYbsmkqqw9mCMdyF8,10932
 openai_sdk_helpers/context_manager.py,sha256=QqlrtenwKoz2krY0IzuToKdTX1HptUYtIEylxieybgY,6633
 openai_sdk_helpers/deprecation.py,sha256=VF0VDDegawYhsu5f-vE6dop9ob-jv8egxsm0KsPvP9E,4753
-openai_sdk_helpers/environment.py,sha256=PqH9viiGIgRAiwU8xPPWlE25KbgSBLmE6nj7S8izCV4,1491
+openai_sdk_helpers/environment.py,sha256=9SYGAgf6dp0aknDdvcnSD40vJWONZsVhO-i8Ayo3jpg,1906
 openai_sdk_helpers/errors.py,sha256=0TLrcpRXPBvk2KlrU5I1VAQl-sYy-d15h_SMDkEawvI,2757
 openai_sdk_helpers/files_api.py,sha256=uMKHvGg1Od0J95Izl3AG9ofQYq8EDJXEty7zP0oKjJM,12569
 openai_sdk_helpers/logging_config.py,sha256=JcR0FTWht1tYdwD-bXH835pr0JV0RwHfY3poruiZGHM,795
@@ -11,9 +11,9 @@ openai_sdk_helpers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openai_sdk_helpers/retry.py,sha256=J10oQYphfzDXm3BnLoXwxk7PAhN93TC2LQOv0VDGOwI,6533
 openai_sdk_helpers/tools.py,sha256=Awj5htt1ImBbNToM1u6qdrIZ-7MiPZAXZ_oKKiWivy8,10547
 openai_sdk_helpers/types.py,sha256=xzldCRfwCZ3rZl18IBmfgA-PVdoZKSWNrlSIhirumSo,1451
-openai_sdk_helpers/agent/__init__.py,sha256=rWJks5wZ-AP1vsZoxROXCeVen_twE269FJLqdpNIKS0,1086
-openai_sdk_helpers/agent/base.py,sha256=5G2ELmdR8wPOLuppzqDzflW2se7pSmfYEf9_drcSN9I,20914
-openai_sdk_helpers/agent/config.py,sha256=SOEX0-G0jDgrCNiHFYCMCk-K-oP4fWapTxtDvgF7FXc,15939
+openai_sdk_helpers/agent/__init__.py,sha256=39nYVK8okZv_srC86HStwtKirkH1_FXkacoqfV73naA,1070
+openai_sdk_helpers/agent/base.py,sha256=iv14LURB5PFcbRHuP1lWyj8JbKvDqM1m1Tf1mOi6CA8,27080
+openai_sdk_helpers/agent/config.py,sha256=NlSE1T1T3fUOu4GJzwjmrVGxB1aI969yYg6sFXgwHCI,14611
 openai_sdk_helpers/agent/coordination.py,sha256=VTzyl4RV1q4ugiyFW4Fj7pOAVVO0bMRD63PfQRDwfoQ,18030
 openai_sdk_helpers/agent/prompt_utils.py,sha256=-1M66tqQxh9wWCFg6X-K7cCcqauca3yA04ZjvOpN3bA,337
 openai_sdk_helpers/agent/runner.py,sha256=aOVN1OYKK5_u7oFBqRCOOeTgcb-lLl4kZGxuPLmJrMw,4884
@@ -21,10 +21,10 @@ openai_sdk_helpers/agent/summarizer.py,sha256=lg_PLB1DSHox3PNDgiCzvCPM5VoCUbKEMG
 openai_sdk_helpers/agent/translator.py,sha256=3u7er1GhUGdy7OMa3A_vyqFFZfev3XBCZW_6w5OwYVc,6286
 openai_sdk_helpers/agent/utils.py,sha256=DTD5foCqGYfXf13F2bZMYIQROl7SbDSy5GDPGi0Zl-0,1089
 openai_sdk_helpers/agent/validation.py,sha256=6NHZIFaUOqRZeYqvRBnDc_uApAV3YHJnOhLHKbVUsi0,5094
-openai_sdk_helpers/agent/search/__init__.py,sha256=xqosfzH4HcBs9IFZks9msG_694rS5q6Ea4_qNeRQRmU,798
+openai_sdk_helpers/agent/search/__init__.py,sha256=LXXzEcX2MU7_htHRdRCGPw0hsr9CrZn0ESii7GZJMBw,806
 openai_sdk_helpers/agent/search/base.py,sha256=VokTw3-V2yxGzm2WzlcvU100h3UaeyGslCFwIgMvJwI,10146
-openai_sdk_helpers/agent/search/vector.py,sha256=i5nWUvEE9eAv41FwbMT52uORZ7OHCEc8d4F6qH-klCc,14282
-openai_sdk_helpers/agent/search/web.py,sha256=7rYvFAZ1S00IaFPcneEOP2yY2vKIvYdnJvAbVTRbESc,10767
+openai_sdk_helpers/agent/search/vector.py,sha256=A1HskDI6YVd3D9IQncowgiWUy9ptlMlSJhrBRDyqroM,15167
+openai_sdk_helpers/agent/search/web.py,sha256=EQ0Rgcz21Rm9bDGPr8XPlDj34_nH2wnB7ER9rBy48Ak,11199
 openai_sdk_helpers/enums/__init__.py,sha256=aFf79C4JBeLC3kMlJfSpehyjx5uNCtW6eK5rD6ZFfhM,322
 openai_sdk_helpers/enums/base.py,sha256=cNllDtzcgI0_eZYXxFko14yhxwicX6xbeDfz9gFE3qo,2753
 openai_sdk_helpers/prompt/__init__.py,sha256=MOqgKwG9KLqKudoKRlUfLxiSmdOi2aD6hNrWDFqLHkk,418
@@ -34,16 +34,18 @@ openai_sdk_helpers/prompt/translator.jinja,sha256=SZhW8ipEzM-9IA4wyS_r2wIMTAclWr
 openai_sdk_helpers/prompt/validator.jinja,sha256=6t8q_IdxFd3mVBGX6SFKNOert1Wo3YpTOji2SNEbbtE,547
 openai_sdk_helpers/response/__init__.py,sha256=Rh3tBygneOhS-Er_4dtX4Xa69ukvxYv01brq26VpgwQ,1886
 openai_sdk_helpers/response/base.py,sha256=OA1p9h6EIzwt8VCWFXEalaQHOe0_eZDefqs5jQKu-vU,34844
-openai_sdk_helpers/response/config.py,sha256=KsfLKnh8mPTn15l26JK_BCqPj3CqyArW-L30ceYRNpk,8903
+openai_sdk_helpers/response/config.py,sha256=ugZIP29krecf6JXiwkrc1nBDCdT_C9DSOCdPkLRN4wY,9305
 openai_sdk_helpers/response/files.py,sha256=6iHXeNZg4R08ilQ7D53qIJDQGYPpTLcByAhNJlEwbZ4,13226
 openai_sdk_helpers/response/messages.py,sha256=qX3sW79rLuJEys28zyv5MovZikwGOaLevzdVN0VYMRE,10104
+openai_sdk_helpers/response/planner.py,sha256=OfqrANheofY2155kVVfAWPPAHlnSnhaF0MLUHwNgPBU,333
+openai_sdk_helpers/response/prompter.py,sha256=vaHrNAAB9Z5WYwQeTKfOkAoH6DaFx1aRcywngqr47Pc,337
 openai_sdk_helpers/response/runner.py,sha256=Rg8XmxU5UwxJc3MjPlYlXWDimxy_cjxzefGiruNZK6s,4269
 openai_sdk_helpers/response/tool_call.py,sha256=c9Filh4IG5H_RWuJlYl6KUZDaF7mCjkabFRQMNiz7zM,7422
 openai_sdk_helpers/response/vector_store.py,sha256=cG5Mzdhjw5FsX1phgclIGz2MQ8f8uMKBaage1O2EZQU,3074
-openai_sdk_helpers/streamlit_app/__init__.py,sha256=RjJbnBDS5_YmAmxvaa3phB5u9UcXsXDEk_jMlY_pa5Q,793
+openai_sdk_helpers/streamlit_app/__init__.py,sha256=DIXClgbzncsex2vnXUGjBwvykazx4-Bz089beZiq8vc,805
 openai_sdk_helpers/streamlit_app/app.py,sha256=jNkMQ4zkfojP501qk_vncyLN4TymiDXxA3cXkUvBfsw,17402
-openai_sdk_helpers/streamlit_app/config.py,sha256=Jla8IoKsazHBq71pDFUGEv8W23WE18GSmAKcTI5LCww,16042
-openai_sdk_helpers/streamlit_app/streamlit_web_search.py,sha256=21xhBhdTsqK6ybPcLzSKSLOVeK8a3x9y_rRNvNBOAGM,2812
+openai_sdk_helpers/streamlit_app/config.py,sha256=t1fylt53eVmnNOfBXwpfDyG-Jji9JBUb0ZyrtUWBZ1s,16594
+openai_sdk_helpers/streamlit_app/streamlit_web_search.py,sha256=-5T22a7XbNDjQxC3pLySH85iAdlqSM2ZrR4ZIIYk_KA,2808
 openai_sdk_helpers/structure/__init__.py,sha256=jROw0IbXYVRD2Eb3dBMsB6amQZrX8X7XSgGh_zjsZWc,3469
 openai_sdk_helpers/structure/agent_blueprint.py,sha256=VyJWkgPNzAYKRDMeR1M4kE6qqQURnwqtrrEn0TRJf0g,9698
 openai_sdk_helpers/structure/base.py,sha256=7JuHxKkLR5gP0RWGQIjOQlvySfain6LrB4-zHb0oFxo,25298
@@ -60,7 +62,7 @@ openai_sdk_helpers/structure/plan/helpers.py,sha256=Vc6dBTMFrNWlsaCTpEImEIKjfFq4
 openai_sdk_helpers/structure/plan/plan.py,sha256=CStfSfCdcv7HfLWV_G09xElJvq_kAKi_6JDkB3I7cSI,9663
 openai_sdk_helpers/structure/plan/task.py,sha256=FSdt2OJ_arC60zMoWIUHMT3U1syWM_7svyTpOIwiRSM,4580
 openai_sdk_helpers/structure/plan/types.py,sha256=7y9QEVdZreQUXV7n-R4RoNZzw5HeOVbJGWx9QkSfuNY,418
-openai_sdk_helpers/utils/__init__.py,sha256=le6bj7RDCM5IQv8lh2mJ1dlnUggwhsNGM_zFYba_4PM,3670
+openai_sdk_helpers/utils/__init__.py,sha256=8SghfmiFhNhMj8Wuop1SAtEt1F8QJb_r4jhi5DtSCDE,3670
 openai_sdk_helpers/utils/async_utils.py,sha256=9KbPEVfi6IXdbwkTUE0h5DleK8TI7I6P_VPL8UgUv98,3689
 openai_sdk_helpers/utils/coercion.py,sha256=Pq1u7tAbD7kTZ84lK-7Fb9CyYKKKQt4fypG5BlSI6oQ,3774
 openai_sdk_helpers/utils/deprecation.py,sha256=VF0VDDegawYhsu5f-vE6dop9ob-jv8egxsm0KsPvP9E,4753
@@ -68,19 +70,19 @@ openai_sdk_helpers/utils/encoding.py,sha256=oDtlNGZ5p-edXiHW76REs-0-8NXkQNReKJdj
 openai_sdk_helpers/utils/instructions.py,sha256=trbjxjxv2otQR9VmBsPFk1_CJj8nA85Sgtj_5QmQOKI,942
 openai_sdk_helpers/utils/output_validation.py,sha256=3DC6Hr6vAFx_bQGaLsxkGN_LuKe_MugLpVogMBgG9tc,12621
 openai_sdk_helpers/utils/path_utils.py,sha256=NOSX7553cc8LqxbnvmdYjgDBi5Le2W2LuMINwFsTzyM,1969
-openai_sdk_helpers/utils/registry.py,sha256=qJrhPRbrw3y0gaqvsdUz2IsTRxClWZ4oLqHwhxTJjUc,5873
+openai_sdk_helpers/utils/registry.py,sha256=m59q6qm2IqXRdvdeKB-7H5tiUs1SB-aXTuyhTsVH5E4,6499
 openai_sdk_helpers/utils/validation.py,sha256=ZjnZNOy5AoFlszRxarNol6YZwfgw6LnwPtkCekZmwAU,7826
 openai_sdk_helpers/utils/json/__init__.py,sha256=wBm1DBgfy_n1uSUcnCPyqBn_cCq41mijjPigSMZJZqg,2118
 openai_sdk_helpers/utils/json/base_model.py,sha256=8j__oKly46RRekmRjwFZjAxBHhZkIjMADcJReKo-QsQ,5100
 openai_sdk_helpers/utils/json/data_class.py,sha256=hffMQQTNTwybuMTOtmKNzxd6kXrVyQen67F5BE_OGqE,6469
-openai_sdk_helpers/utils/json/ref.py,sha256=jIzv3M96G1b9x2tW8JZBqKBxAsE3bUhVmMADBFH6Jb4,2806
+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=A6zJDicObdSOVSlzhHVxEGq_tKO2_bNcsYi94xsKDNI,23655
 openai_sdk_helpers/vector_storage/types.py,sha256=jTCcOYMeOpZWvcse0z4T3MVs-RBOPC-fqWTBeQrgafU,1639
-openai_sdk_helpers-0.4.0.dist-info/METADATA,sha256=bRSOBilp9Y0zr8r2VNKSMTJHSBWoV2aH_HQw7diindo,23557
-openai_sdk_helpers-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-openai_sdk_helpers-0.4.0.dist-info/entry_points.txt,sha256=gEOD1ZeXe8d2OP-KzUlG-b_9D9yUZTCt-GFW3EDbIIY,63
-openai_sdk_helpers-0.4.0.dist-info/licenses/LICENSE,sha256=CUhc1NrE50bs45tcXF7OcTQBKEvkUuLqeOHgrWQ5jaA,1067
-openai_sdk_helpers-0.4.0.dist-info/RECORD,,
+openai_sdk_helpers-0.4.2.dist-info/METADATA,sha256=h1-_VwnRxkgrCwRJMEwpqMe3TCeUuMQ0U-PwYoJrJkU,23557
+openai_sdk_helpers-0.4.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+openai_sdk_helpers-0.4.2.dist-info/entry_points.txt,sha256=gEOD1ZeXe8d2OP-KzUlG-b_9D9yUZTCt-GFW3EDbIIY,63
+openai_sdk_helpers-0.4.2.dist-info/licenses/LICENSE,sha256=CUhc1NrE50bs45tcXF7OcTQBKEvkUuLqeOHgrWQ5jaA,1067
+openai_sdk_helpers-0.4.2.dist-info/RECORD,,