grasp_agents 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

grasp_agents/agent_message.py

@@ -4,7 +4,6 @@ from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
 
-# from .base_agent import StateT
 from .typing.io import AgentID, AgentPayload, AgentState
 
 _PayloadT = TypeVar("_PayloadT", bound=AgentPayload, covariant=True)  # noqa: PLC0105

grasp_agents/base_agent.py

@@ -68,5 +68,5 @@ class BaseAgent(ABC, Generic[OutT, StateT, CtxT]):
     @abstractmethod
     def as_tool(
         self, tool_name: str, tool_description: str, tool_strict: bool = True
-    ) -> BaseTool[BaseModel, BaseModel, CtxT]:
+    ) -> BaseTool[BaseModel, Any, CtxT]:
         pass

grasp_agents/cloud_llm.py

@@ -3,6 +3,7 @@ import logging
 import os
 from abc import abstractmethod
 from collections.abc import AsyncIterator, Sequence
+from copy import deepcopy
 from typing import Any, Generic, Literal
 
 import httpx
@@ -19,7 +20,6 @@ from .data_retrieval.rate_limiter_chunked import (  # type: ignore
     RateLimiterC,
     limit_rate_chunked,
 )
-
 from .http_client import AsyncHTTPClientParams, create_async_http_client
 from .llm import LLM, ConvertT, LLMSettings, SettingsT
 from .memory import MessageHistory
@@ -38,7 +38,7 @@ class APIProviderInfo(TypedDict):
     name: APIProvider
     base_url: str
     api_key: str | None
-    struct_output_support: list[str]
+    struct_output_support: tuple[str, ...]
 
 
 PROVIDERS: dict[APIProvider, APIProviderInfo] = {
@@ -46,19 +46,19 @@ PROVIDERS: dict[APIProvider, APIProviderInfo] = {
         name="openai",
         base_url="https://api.openai.com/v1",
         api_key=os.getenv("OPENAI_API_KEY"),
-        struct_output_support=["*"],
+        struct_output_support=("*",),
     ),
     "openrouter": APIProviderInfo(
         name="openrouter",
         base_url="https://openrouter.ai/api/v1",
         api_key=os.getenv("OPENROUTER_API_KEY"),
-        struct_output_support=[],
+        struct_output_support=(),
     ),
     "google_ai_studio": APIProviderInfo(
         name="google_ai_studio",
         base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
         api_key=os.getenv("GOOGLE_AI_STUDIO_API_KEY"),
-        struct_output_support=["*"],
+        struct_output_support=("*",),
     ),
 }
 
@@ -92,6 +92,7 @@ class CloudLLMSettings(LLMSettings, total=False):
     temperature: float | None
     top_p: float | None
     seed: int | None
+    use_structured_outputs: bool
 
 
 class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
@@ -102,7 +103,7 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
         converters: ConvertT,
         llm_settings: SettingsT | None = None,
         model_id: str | None = None,
-        tools: list[BaseTool[BaseModel, BaseModel, Any]] | None = None,
+        tools: list[BaseTool[BaseModel, Any, Any]] | None = None,
         response_format: type | None = None,
         # Connection settings
         api_provider: APIProvider = "openai",
@@ -135,13 +136,21 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
         self._model_name = model_name
         self._api_provider: APIProvider = api_provider
 
-        patterns = PROVIDERS[api_provider]["struct_output_support"]
         self._struct_output_support: bool = any(
-            fnmatch.fnmatch(self._model_name, pat) for pat in patterns
+            fnmatch.fnmatch(self._model_name, pat)
+            for pat in PROVIDERS[api_provider]["struct_output_support"]
         )
         self._response_format_pyd: TypeAdapter[Any] | None = (
             TypeAdapter(self._response_format) if response_format else None
         )
+        if (
+            self._llm_settings.get("use_structured_outputs")
+            and not self._struct_output_support
+        ):
+            raise ValueError(
+                f"Model {api_provider}:{self._model_name} does "
+                "not support structured outputs."
+            )
 
         self._rate_limiter: RateLimiterC[Conversation, AssistantMessage] | None = (
             self._get_rate_limiter(
@@ -181,8 +190,8 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
     def _make_completion_kwargs(
         self, conversation: Conversation, tool_choice: ToolChoice | None = None
     ) -> dict[str, Any]:
-        api_llm_settings = self.llm_settings or {}
         api_messages = [self._converters.to_message(m) for m in conversation]
+
         api_tools = None
         api_tool_choice = None
         if self.tools:
@@ -190,6 +199,9 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
             if tool_choice is not None:
                 api_tool_choice = self._converters.to_tool_choice(tool_choice)
 
+        api_llm_settings = deepcopy(self.llm_settings or {})
+        api_llm_settings.pop("use_structured_outputs", None)
+
         return dict(
             api_messages=api_messages,
             api_tools=api_tools,
@@ -216,6 +228,7 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
         *,
         api_tools: list[Any] | None = None,
         api_tool_choice: Any | None = None,
+        api_response_format: type | None = None,
         **api_llm_settings: Any,
     ) -> Any:
         pass
@@ -242,7 +255,11 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
             conversation=conversation, tool_choice=tool_choice
         )
 
-        if self._response_format is None or not self._struct_output_support:
+        if (
+            self._response_format is None
+            or (not self._struct_output_support)
+            or (not self._llm_settings.get("use_structured_outputs"))
+        ):
             completion_kwargs.pop("api_response_format", None)
             api_completion = await self._get_completion(**completion_kwargs, **kwargs)
         else:
@@ -250,7 +267,23 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
                 **completion_kwargs, **kwargs
             )
 
-        return self._converters.from_completion(api_completion, model_id=self.model_id)
+        completion = self._converters.from_completion(
+            api_completion, model_id=self.model_id
+        )
+
+        for choice in completion.choices:
+            message = choice.message
+            if (
+                self._response_format_pyd is not None
+                and not self._llm_settings.get("use_structured_outputs")
+                and not message.tool_calls
+            ):
+                message_json = extract_json(
+                    message.content, return_none_on_failure=True
+                )
+                self._response_format_pyd.validate_python(message_json)
+
+        return completion
 
     async def generate_completion_stream(
         self,
@@ -271,63 +304,73 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
             api_completion_chunk_iterator, model_id=self.model_id
         )
 
-    async def generate_message(
-        self,
-        conversation: Conversation,
-        *,
-        tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
-    ) -> AssistantMessage:
-        completion = await self.generate_completion(
-            conversation, tool_choice=tool_choice, **kwargs
-        )
-        message = completion.choices[0].message
-        if self._response_format_pyd is not None and not self._struct_output_support:
-            self._response_format_pyd.validate_python(extract_json(message.content))
-
-        return message
-
-    async def _generate_message_with_retry(
+    async def _generate_completion_with_retry(
         self,
         conversation: Conversation,
         *,
         tool_choice: ToolChoice | None = None,
         **kwargs: Any,
-    ) -> AssistantMessage:
+    ) -> Completion:
         wrapped_func = retry(
             wait=wait_random_exponential(min=1, max=8),
             stop=stop_after_attempt(self.num_generation_retries + 1),
             before=retry_before_callback,
             retry_error_callback=retry_error_callback,
-        )(self.__class__.generate_message)
+        )(self.__class__.generate_completion)
 
         return await wrapped_func(self, conversation, tool_choice=tool_choice, **kwargs)
 
     @limit_rate_chunked  # type: ignore
-    async def _generate_message_batch_with_retry_and_rate_lim(
+    async def _generate_completion_batch_with_retry_and_rate_lim(
         self,
         conversation: Conversation,
         *,
         tool_choice: ToolChoice | None = None,
         **kwargs: Any,
-    ) -> AssistantMessage:
-        return await self._generate_message_with_retry(
+    ) -> Completion:
+        return await self._generate_completion_with_retry(
             conversation, tool_choice=tool_choice, **kwargs
         )
 
-    async def generate_message_batch(
+    async def generate_completion_batch(
         self,
         message_history: MessageHistory,
         *,
         tool_choice: ToolChoice | None = None,
         **kwargs: Any,
-    ) -> Sequence[AssistantMessage]:
-        return await self._generate_message_batch_with_retry_and_rate_lim(
+    ) -> Sequence[Completion]:
+        return await self._generate_completion_batch_with_retry_and_rate_lim(
             list(message_history.batched_conversations),  # type: ignore
             tool_choice=tool_choice,
             **kwargs,
         )
 
+    async def generate_message(
+        self,
+        conversation: Conversation,
+        *,
+        tool_choice: ToolChoice | None = None,
+        **kwargs: Any,
+    ) -> AssistantMessage:
+        completion = await self.generate_completion(
+            conversation, tool_choice=tool_choice, **kwargs
+        )
+
+        return completion.choices[0].message
+
+    async def generate_message_batch(
+        self,
+        message_history: MessageHistory,
+        *,
+        tool_choice: ToolChoice | None = None,
+        **kwargs: Any,
+    ) -> Sequence[AssistantMessage]:
+        completion_batch = await self.generate_completion_batch(
+            message_history, tool_choice=tool_choice, **kwargs
+        )
+
+        return [completion.choices[0].message for completion in completion_batch]
+
     def _get_rate_limiter(
         self,
         rate_limiter: RateLimiterC[Conversation, AssistantMessage] | None = None,

grasp_agents/comm_agent.py

@@ -4,6 +4,7 @@ from collections.abc import Sequence
 from typing import Any, Generic, Protocol, TypeVar, cast, final
 
 from pydantic import BaseModel
+from pydantic.json_schema import SkipJsonSchema
 
 from .agent_message import AgentMessage
 from .agent_message_pool import AgentMessagePool
@@ -14,6 +15,11 @@ from .typing.tool import BaseTool
 
 logger = logging.getLogger(__name__)
 
+
+class DCommAgentPayload(AgentPayload):
+    selected_recipient_ids: SkipJsonSchema[Sequence[AgentID]]
+
+
 _EH_OutT = TypeVar("_EH_OutT", bound=AgentPayload, contravariant=True)  # noqa: PLC0105
 _EH_StateT = TypeVar("_EH_StateT", bound=AgentState, contravariant=True)  # noqa: PLC0105
 
@@ -22,7 +28,6 @@ class ExitHandler(Protocol[_EH_OutT, _EH_StateT, CtxT]):
     def __call__(
         self,
         output_message: AgentMessage[_EH_OutT, _EH_StateT],
-        agent_state: _EH_StateT,
         ctx: RunContextWrapper[CtxT] | None,
     ) -> bool: ...
 
@@ -38,14 +43,11 @@ class CommunicatingAgent(
         rcv_args_schema: type[InT] = AgentPayload,
         recipient_ids: Sequence[AgentID] | None = None,
         message_pool: AgentMessagePool[CtxT] | None = None,
-        dynamic_routing: bool = False,
         **kwargs: Any,
     ) -> None:
         super().__init__(agent_id=agent_id, out_schema=out_schema, **kwargs)
         self._message_pool = message_pool or AgentMessagePool()
 
-        self._dynamic_routing = dynamic_routing
-
         self._is_listening = False
         self._exit_impl: ExitHandler[OutT, StateT, CtxT] | None = None
 
@@ -56,10 +58,6 @@ class CommunicatingAgent(
     def rcv_args_schema(self) -> type[InT]:  # type: ignore[reportInvalidTypeVarUse]
         return self._rcv_args_schema
 
-    @property
-    def dynamic_routing(self) -> bool:
-        return self._dynamic_routing
-
     def _parse_output(
         self,
         *args: Any,
@@ -72,41 +70,36 @@ class CommunicatingAgent(
 
         return self._out_schema()
 
-    def _validate_dynamic_routing(self, payloads: Sequence[OutT]) -> Sequence[AgentID]:
-        assert all((p.selected_recipient_ids is not None) for p in payloads), (
-            "Dynamic routing is enabled, but some payloads have no recipient IDs"
-        )
-
-        selected_recipient_ids_per_payload = [
-            set(p.selected_recipient_ids or []) for p in payloads
-        ]
-        assert all(
-            x == selected_recipient_ids_per_payload[0]
-            for x in selected_recipient_ids_per_payload
-        ), "All payloads must have the same recipient IDs for dynamic routing"
-
-        assert payloads[0].selected_recipient_ids is not None
-        selected_recipient_ids = payloads[0].selected_recipient_ids
+    def _validate_routing(self, payloads: Sequence[OutT]) -> Sequence[AgentID]:
+        if all(isinstance(p, DCommAgentPayload) for p in payloads):
+            payloads_ = cast("Sequence[DCommAgentPayload]", payloads)
+            selected_recipient_ids_per_payload = [
+                set(p.selected_recipient_ids or []) for p in payloads_
+            ]
+            assert all(
+                x == selected_recipient_ids_per_payload[0]
+                for x in selected_recipient_ids_per_payload
+            ), "All payloads must have the same recipient IDs for dynamic routing"
+
+            assert payloads_[0].selected_recipient_ids is not None
+            selected_recipient_ids = payloads_[0].selected_recipient_ids
+
+            assert all(rid in self.recipient_ids for rid in selected_recipient_ids), (
+                "Dynamic routing is enabled, but recipient IDs are not in "
+                "the allowed agent's recipient IDs"
+            )
 
-        assert all(rid in self.recipient_ids for rid in selected_recipient_ids), (
-            "Dynamic routing is enabled, but recipient IDs are not in "
-            "the allowed agent's recipient IDs"
-        )
+            return selected_recipient_ids
 
-        return selected_recipient_ids
+        if all((not isinstance(p, DCommAgentPayload)) for p in payloads):
+            return self.recipient_ids
 
-    def _validate_static_routing(self, payloads: Sequence[OutT]) -> Sequence[AgentID]:
-        assert all((p.selected_recipient_ids is None) for p in payloads), (
-            "Dynamic routing is not enabled, but some payloads have recipient IDs"
+        raise ValueError(
+            "All payloads must be either DCommAgentPayload or not DCommAgentPayload"
         )
 
-        return self.recipient_ids
-
     async def post_message(self, message: AgentMessage[OutT, StateT]) -> None:
-        if self._dynamic_routing:
-            self._validate_dynamic_routing(message.payloads)
-        else:
-            self._validate_static_routing(message.payloads)
+        self._validate_routing(message.payloads)
 
         await self._message_pool.post(message)
 
@@ -144,9 +137,7 @@ class CommunicatingAgent(
         ctx: RunContextWrapper[CtxT] | None,
     ) -> bool:
         if self._exit_impl:
-            return self._exit_impl(
-                output_message=output_message, agent_state=self.state, ctx=ctx
-            )
+            return self._exit_impl(output_message=output_message, ctx=ctx)
 
         return False
 
@@ -190,28 +181,28 @@ class CommunicatingAgent(
 
     @final
     def as_tool(
-        self, tool_name: str, tool_description: str, tool_strict: bool = True
-    ) -> BaseTool[BaseModel, BaseModel, CtxT]:
-        # assert self.state.batch_size == 1, (
-        #     "Using agents as tools is only supported for batch size 1"
-        # )
-
+        self,
+        tool_name: str,
+        tool_description: str,
+        tool_strict: bool = True,
+    ) -> BaseTool[Any, Any, Any]:
         agent_instance = self
 
-        class AgentTool(BaseTool[BaseModel, BaseModel, Any]):
+        class AgentTool(BaseTool[Any, Any, Any]):
             name: str = tool_name
             description: str = tool_description
             in_schema: type[BaseModel] = agent_instance.rcv_args_schema
-            out_schema: type[BaseModel] = agent_instance.out_schema
+            out_schema: Any = agent_instance.out_schema
 
             strict: bool | None = tool_strict
 
             async def run(
                 self,
-                inp: BaseModel,
+                inp: InT,
                 ctx: RunContextWrapper[CtxT] | None = None,
             ) -> OutT:
                 rcv_args = agent_instance.rcv_args_schema.model_validate(inp)
+
                 rcv_message = AgentMessage(  # type: ignore[arg-type]
                     payloads=[rcv_args],
                     sender_id="<tool_user>",

grasp_agents/llm.py

@@ -1,7 +1,7 @@
 import logging
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Sequence
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, TypeVar, cast
 from uuid import uuid4
 
 from pydantic import BaseModel
@@ -32,7 +32,7 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         model_name: str | None = None,
         model_id: str | None = None,
         llm_settings: SettingsT | None = None,
-        tools: list[BaseTool[BaseModel, BaseModel, Any]] | None = None,
+        tools: list[BaseTool[BaseModel, Any, Any]] | None = None,
         response_format: type | None = None,
         **kwargs: Any,
     ) -> None:
@@ -41,9 +41,9 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         self._converters = converters
         self._model_id = model_id or str(uuid4())[:8]
         self._model_name = model_name
-        self._llm_settings = llm_settings
         self._tools = {t.name: t for t in tools} if tools else None
         self._response_format = response_format
+        self._llm_settings: SettingsT = llm_settings or cast("SettingsT", {})
 
     @property
     def model_id(self) -> str:
@@ -54,11 +54,11 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         return self._model_name
 
     @property
-    def llm_settings(self) -> SettingsT | None:
+    def llm_settings(self) -> SettingsT:
         return self._llm_settings
 
     @property
-    def tools(self) -> dict[str, BaseTool[BaseModel, BaseModel, Any]] | None:
+    def tools(self) -> dict[str, BaseTool[BaseModel, Any, Any]] | None:
         return self._tools
 
     @property
@@ -66,7 +66,7 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         return self._response_format
 
     @tools.setter
-    def tools(self, tools: list[BaseTool[BaseModel, BaseModel, Any]] | None) -> None:
+    def tools(self, tools: list[BaseTool[BaseModel, Any, Any]] | None) -> None:
         self._tools = {t.name: t for t in tools} if tools else None
 
     def __repr__(self) -> str:

grasp_agents/llm_agent.py

@@ -33,6 +33,8 @@ from .typing.io import (
     AgentPayload,
     AgentState,
     InT,
+    LLMFormattedArgs,
+    LLMFormattedSystemArgs,
     LLMPrompt,
     LLMPromptArgs,
     OutT,
@@ -67,7 +69,7 @@ class LLMAgent(
         # Output schema
         out_schema: type[OutT] = cast("type[OutT]", AgentPayload),
         # Tools
-        tools: list[BaseTool[BaseModel, BaseModel, CtxT]] | None = None,
+        tools: list[BaseTool[Any, Any, CtxT]] | None = None,
         max_turns: int = 1000,
         react_mode: bool = False,
         # Agent state management
@@ -75,7 +77,6 @@ class LLMAgent(
         # Multi-agent routing
         message_pool: AgentMessagePool[CtxT] | None = None,
         recipient_ids: list[AgentID] | None = None,
-        dynamic_routing: bool = False,
     ) -> None:
         super().__init__(
             agent_id=agent_id,
@@ -83,7 +84,6 @@ class LLMAgent(
             rcv_args_schema=rcv_args_schema,
             message_pool=message_pool,
             recipient_ids=recipient_ids,
-            dynamic_routing=dynamic_routing,
         )
 
         # Agent state
@@ -114,12 +114,24 @@ class LLMAgent(
 
         self.no_tqdm = getattr(llm, "no_tqdm", False)
 
+        if type(self)._format_sys_args is not LLMAgent[Any, Any, Any]._format_sys_args:  # noqa: SLF001
+            self._prompt_builder.format_sys_args_impl = self._format_sys_args
+
+        if type(self)._format_inp_args is not LLMAgent[Any, Any, Any]._format_inp_args:  # noqa: SLF001
+            self._prompt_builder.format_inp_args_impl = self._format_inp_args
+
+        if (
+            type(self)._tool_call_loop_exit  # noqa: SLF001
+            is not LLMAgent[Any, Any, Any]._tool_call_loop_exit  # noqa: SLF001
+        ):
+            self._tool_orchestrator.tool_call_loop_exit_impl = self._tool_call_loop_exit
+
     @property
     def llm(self) -> LLM[LLMSettings, Converters]:
         return self._tool_orchestrator.llm
 
     @property
-    def tools(self) -> dict[str, BaseTool[BaseModel, BaseModel, CtxT]]:
+    def tools(self) -> dict[str, BaseTool[BaseModel, Any, CtxT]]:
         return self._tool_orchestrator.tools
 
     @property
@@ -142,37 +154,10 @@ class LLMAgent(
     def inp_prompt(self) -> LLMPrompt | None:
         return self._prompt_builder.inp_prompt
 
-    def format_sys_args_handler(
-        self, func: FormatSystemArgsHandler[CtxT]
-    ) -> FormatSystemArgsHandler[CtxT]:
-        self._prompt_builder.format_sys_args_impl = func
-
-        return func
-
-    def format_inp_args_handler(
-        self, func: FormatInputArgsHandler[InT, CtxT]
-    ) -> FormatInputArgsHandler[InT, CtxT]:
-        self._prompt_builder.format_inp_args_impl = func
-
-        return func
-
-    def make_custom_agent_state_handler(
-        self, func: MakeCustomAgentState
-    ) -> MakeCustomAgentState:
-        self._make_custom_agent_state_impl = func
-
-        return func
-
-    def tool_call_loop_exit_handler(
-        self, func: ToolCallLoopExitHandler[CtxT]
-    ) -> ToolCallLoopExitHandler[CtxT]:
-        self._tool_orchestrator.tool_call_loop_exit_impl = func
-
-        return func
-
     def _parse_output(
         self,
         conversation: Conversation,
+        *,
         rcv_args: InT | None = None,
         ctx: RunContextWrapper[CtxT] | None = None,
         **kwargs: Any,
@@ -274,10 +259,7 @@ class LLMAgent(
 
         # 6. Write interaction history to context
 
-        if self.dynamic_routing:
-            recipient_ids = self._validate_dynamic_routing(val_output_batch)
-        else:
-            recipient_ids = self._validate_static_routing(val_output_batch)
+        recipient_ids = self._validate_routing(val_output_batch)
 
         if ctx:
             interaction_record = InteractionRecord(
@@ -332,30 +314,66 @@ class LLMAgent(
         ):
             self._print_msgs([state.message_history[0][0]], ctx=ctx)
 
-    # def _format_sys_args(
-    #     self,
-    #     sys_args: LLMPromptArgs,
-    #     ctx: RunContextWrapper[CtxT] | None = None,
-    # ) -> LLMFormattedSystemArgs:
-    #     return self._prompt_builder.format_sys_args(sys_args=sys_args, ctx=ctx)
-
-    # def _format_inp_args(
-    #     self,
-    #     usr_args: LLMPromptArgs,
-    #     rcv_args: InT,
-    #     ctx: RunContextWrapper[CtxT] | None = None,
-    # ) -> LLMFormattedArgs:
-    #     return self._prompt_builder.format_inp_args(
-    #         usr_args=usr_args, rcv_args=rcv_args, ctx=ctx
-    #     )
-
-    # def _tool_call_loop_exit(
-    #     self,
-    #     conversation: Conversation,
-    #     *,
-    #     ctx: RunContextWrapper[CtxT] | None = None,
-    #     **kwargs: Any,
-    # ) -> bool:
-    #     return self._tool_orchestrator.tool_call_loop_exit(
-    #         conversation=conversation, ctx=ctx, **kwargs
-    #     )
+    # -- Handlers for custom implementations --
+
+    def format_sys_args_handler(
+        self, func: FormatSystemArgsHandler[CtxT]
+    ) -> FormatSystemArgsHandler[CtxT]:
+        self._prompt_builder.format_sys_args_impl = func
+
+        return func
+
+    def format_inp_args_handler(
+        self, func: FormatInputArgsHandler[InT, CtxT]
+    ) -> FormatInputArgsHandler[InT, CtxT]:
+        self._prompt_builder.format_inp_args_impl = func
+
+        return func
+
+    def make_custom_agent_state_handler(
+        self, func: MakeCustomAgentState
+    ) -> MakeCustomAgentState:
+        self._make_custom_agent_state_impl = func
+
+        return func
+
+    def tool_call_loop_exit_handler(
+        self, func: ToolCallLoopExitHandler[CtxT]
+    ) -> ToolCallLoopExitHandler[CtxT]:
+        self._tool_orchestrator.tool_call_loop_exit_impl = func
+
+        return func
+
+    # -- Override these methods in subclasses if needed --
+
+    def _format_sys_args(
+        self,
+        sys_args: LLMPromptArgs,
+        *,
+        ctx: RunContextWrapper[CtxT] | None = None,
+    ) -> LLMFormattedSystemArgs:
+        raise NotImplementedError(
+            "LLMAgent._format_sys_args must be overridden by a subclass "
+            "if it's intended to be used as the system arguments formatter."
+        )
+
+    def _format_inp_args(
+        self,
+        usr_args: LLMPromptArgs,
+        rcv_args: InT,
+        ctx: RunContextWrapper[CtxT] | None = None,
+    ) -> LLMFormattedArgs:
+        raise NotImplementedError(
+            "LLMAgent._format_inp_args must be overridden by a subclass"
+        )
+
+    def _tool_call_loop_exit(
+        self,
+        conversation: Conversation,
+        *,
+        ctx: RunContextWrapper[CtxT] | None = None,
+        **kwargs: Any,
+    ) -> bool:
+        raise NotImplementedError(
+            "LLMAgent._tool_call_loop_exit must be overridden by a subclass"
+        )

grasp_agents/memory.py

@@ -142,9 +142,3 @@ class MessageHistory:
 
     def erase(self) -> None:
         self._batched_conversations = [[]]
-
-    # def get_batch(self, batch_id: int) -> list[Message]:
-    #     return self._batched_conversations[batch_id]
-
-    # def iterate_conversations(self) -> Iterator[list[Message]]:
-    #     return iter(self._batched_conversations)

grasp_agents/openai/completion_converters.py

@@ -13,13 +13,14 @@ def from_api_completion(
     api_completion: ChatCompletion, model_id: str | None = None
 ) -> Completion:
     choices: list[CompletionChoice] = []
-    # TODO: add custom error type
     if api_completion.choices is None:  # type: ignore
-        raise ValueError(
+        # Choices can sometimes be None for some providers using the OpenAI API
+        # TODO: add custom error types
+        raise RuntimeError(
             f"Completion API error: {getattr(api_completion, 'error', None)}"
         )
     for api_choice in api_completion.choices:
-        # TODO: no way to assign individual message usages when len(choices) > 1
+        # TODO: currently no way to assign individual message usages when len(choices) > 1
         message = from_api_assistant_message(
             api_choice.message, api_completion.usage, model_id=model_id
         )

grasp_agents/openai/converters.py

@@ -6,12 +6,7 @@ from pydantic import BaseModel
 from ..typing.completion import Completion, CompletionChunk
 from ..typing.content import Content
 from ..typing.converters import Converters
-from ..typing.message import (
-    AssistantMessage,
-    SystemMessage,
-    ToolMessage,
-    UserMessage,
-)
+from ..typing.message import AssistantMessage, SystemMessage, ToolMessage, UserMessage
 from ..typing.tool import BaseTool, ToolChoice
 from . import (
     ChatCompletion,
@@ -19,7 +14,6 @@ from . import (
     ChatCompletionAsyncStream,  # type: ignore[import]
     ChatCompletionChunk,
     ChatCompletionContentPartParam,
-    # ChatCompletionDeveloperMessageParam,
     ChatCompletionMessage,
     ChatCompletionSystemMessageParam,
     ChatCompletionToolChoiceOptionParam,
@@ -110,7 +104,7 @@ class OpenAIConverters(Converters):
 
     @staticmethod
     def to_tool(
-        tool: BaseTool[BaseModel, BaseModel, Any], **kwargs: Any
+        tool: BaseTool[BaseModel, Any, Any], **kwargs: Any
     ) -> ChatCompletionToolParam:
         return to_api_tool(tool, **kwargs)
 

grasp_agents/openai/message_converters.py

@@ -132,9 +132,6 @@ def to_api_system_message(
     message: SystemMessage,
 ) -> ChatCompletionSystemMessageParam:
     return ChatCompletionSystemMessageParam(role="system", content=message.content)
-    # return ChatCompletionSystemMessageParam(
-    #     role="system", content=message.content
-    # )
 
 
 def from_api_tool_message(
@@ -149,7 +146,5 @@ def from_api_tool_message(
 
 def to_api_tool_message(message: ToolMessage) -> ChatCompletionToolMessageParam:
     return ChatCompletionToolMessageParam(
-        role="tool",
-        content=message.content,
-        tool_call_id=message.tool_call_id,
+        role="tool", content=message.content, tool_call_id=message.tool_call_id
     )

grasp_agents/openai/openai_llm.py

@@ -67,7 +67,7 @@ class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
         model_name: str,
         model_id: str | None = None,
         llm_settings: OpenAILLMSettings | None = None,
-        tools: list[BaseTool[BaseModel, BaseModel, Any]] | None = None,
+        tools: list[BaseTool[BaseModel, Any, Any]] | None = None,
         response_format: type | None = None,
         # Connection settings
         api_provider: APIProvider = "openai",
@@ -113,8 +113,6 @@ class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
             base_url=self._base_url,
             api_key=self._api_key,
             **async_openai_client_params_,
-            # timeout=10.0,
-            # max_retries=3,
         )
 
     async def _get_completion(

grasp_agents/openai/tool_converters.py

@@ -13,7 +13,7 @@ from . import (
 
 
 def to_api_tool(
-    tool: BaseTool[BaseModel, BaseModel, Any],
+    tool: BaseTool[BaseModel, Any, Any],
 ) -> ChatCompletionToolParam:
     return ChatCompletionToolParam(
         type="function",

grasp_agents/tool_orchestrator.py

@@ -31,7 +31,7 @@ class ToolOrchestrator(Generic[CtxT]):
         self,
         agent_id: str,
         llm: LLM[LLMSettings, Converters],
-        tools: list[BaseTool[BaseModel, BaseModel, CtxT]] | None,
+        tools: list[BaseTool[BaseModel, Any, CtxT]] | None,
         max_turns: int,
         react_mode: bool = False,
     ) -> None:
@@ -55,7 +55,7 @@ class ToolOrchestrator(Generic[CtxT]):
         return self._llm
 
     @property
-    def tools(self) -> dict[str, BaseTool[BaseModel, BaseModel, CtxT]]:
+    def tools(self) -> dict[str, BaseTool[BaseModel, Any, CtxT]]:
         return self._llm.tools or {}
 
     @property

grasp_agents/typing/converters.py

@@ -2,17 +2,9 @@ from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator
 from typing import Any
 
-from pydantic import BaseModel
-
 from .completion import Completion, CompletionChunk
 from .content import Content
-from .message import (
-    AssistantMessage,
-    Message,
-    SystemMessage,
-    ToolMessage,
-    UserMessage,
-)
+from .message import AssistantMessage, Message, SystemMessage, ToolMessage, UserMessage
 from .tool import BaseTool, ToolChoice
 
 
@@ -72,7 +64,7 @@ class Converters(ABC):
 
     @staticmethod
     @abstractmethod
-    def to_tool(tool: BaseTool[BaseModel, BaseModel, Any], **kwargs: Any) -> Any:
+    def to_tool(tool: BaseTool[Any, Any, Any], **kwargs: Any) -> Any:
         pass
 
     @staticmethod

grasp_agents/typing/io.py

@@ -1,8 +1,6 @@
-from collections.abc import Sequence
 from typing import TypeAlias, TypeVar
 
 from pydantic import BaseModel
-from pydantic.json_schema import SkipJsonSchema
 
 from .content import ImageData
 
@@ -10,8 +8,7 @@ AgentID: TypeAlias = str
 
 
 class AgentPayload(BaseModel):
-    # TODO: do we need conversation?
-    selected_recipient_ids: SkipJsonSchema[Sequence[AgentID] | None] = None
+    pass
 
 
 class AgentState(BaseModel):

grasp_agents/typing/message.py

@@ -1,9 +1,11 @@
+import json
 from collections.abc import Hashable, Sequence
 from enum import StrEnum
-from typing import Annotated, Literal, TypeAlias
+from typing import Annotated, Any, Literal, TypeAlias
 from uuid import uuid4
 
 from pydantic import BaseModel, Field, NonNegativeFloat, NonNegativeInt
+from pydantic.json import pydantic_encoder
 
 from .content import Content, ImageData
 from .tool import ToolCall
@@ -110,13 +112,13 @@ class ToolMessage(MessageBase):
     @classmethod
     def from_tool_output(
         cls,
-        tool_output: BaseModel,
+        tool_output: Any,
         tool_call: ToolCall,
         model_id: str | None = None,
         indent: int = 2,
     ) -> "ToolMessage":
         return cls(
-            content=tool_output.model_dump_json(indent=indent),
+            content=json.dumps(tool_output, default=pydantic_encoder, indent=indent),
             tool_call_id=tool_call.id,
             model_id=model_id,
         )

grasp_agents/typing/tool.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import asyncio
 from abc import ABC, abstractmethod
+from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, Generic, Literal, TypeAlias, TypeVar
 
-from pydantic import BaseModel
+from pydantic import BaseModel, TypeAdapter
 
 if TYPE_CHECKING:
     from ..run_context import CtxT, RunContextWrapper
@@ -14,8 +16,8 @@ else:
         """Runtime placeholder so RunContextWrapper[CtxT] works"""
 
 
-ToolInT = TypeVar("ToolInT", bound=BaseModel, contravariant=True)  # noqa: PLC0105
-ToolOutT = TypeVar("ToolOutT", bound=BaseModel, covariant=True)  # noqa: PLC0105
+_ToolInT = TypeVar("_ToolInT", bound=BaseModel, contravariant=True)  # noqa: PLC0105
+_ToolOutT = TypeVar("_ToolOutT", covariant=True)  # noqa: PLC0105
 
 
 class ToolCall(BaseModel):
@@ -24,29 +26,34 @@ class ToolCall(BaseModel):
     tool_arguments: str
 
 
-class BaseTool(BaseModel, ABC, Generic[ToolInT, ToolOutT, CtxT]):
+class BaseTool(BaseModel, ABC, Generic[_ToolInT, _ToolOutT, CtxT]):
     name: str
     description: str
-    in_schema: type[ToolInT]
-    out_schema: type[ToolOutT]
+    in_schema: type[_ToolInT]
+    out_schema: type[_ToolOutT]
 
     # Supported by OpenAI API
     strict: bool | None = None
 
     @abstractmethod
     async def run(
-        self, inp: ToolInT, ctx: RunContextWrapper[CtxT] | None = None
-    ) -> ToolOutT:
+        self, inp: _ToolInT, ctx: RunContextWrapper[CtxT] | None = None
+    ) -> _ToolOutT:
         pass
 
+    async def run_batch(
+        self, inp_batch: Sequence[_ToolInT], ctx: RunContextWrapper[CtxT] | None = None
+    ) -> Sequence[_ToolOutT]:
+        return await asyncio.gather(*[self.run(inp, ctx=ctx) for inp in inp_batch])
+
     async def __call__(
         self, ctx: RunContextWrapper[CtxT] | None = None, **kwargs: Any
-    ) -> ToolOutT:
+    ) -> _ToolOutT:
         result = await self.run(self.in_schema(**kwargs), ctx=ctx)
 
-        return self.out_schema.model_validate(result)
+        return TypeAdapter(self.out_schema).validate_python(result)
 
 
 ToolChoice: TypeAlias = (
-    Literal["none", "auto", "required"] | BaseTool[BaseModel, BaseModel, Any]
+    Literal["none", "auto", "required"] | BaseTool[BaseModel, Any, Any]
 )

grasp_agents/utils.py

@@ -1,57 +1,39 @@
 import ast
+import functools
 import asyncio
 from datetime import datetime
-import functools
 import json
 import re
-from collections.abc import Callable, Coroutine
+from logging import getLogger
+from collections.abc import Callable
 from copy import deepcopy
 from pathlib import Path
-from typing import Any, TypeVar, cast
-
-from pydantic import BaseModel, create_model
-from pydantic.fields import FieldInfo
+from typing import Any, TypeVar, cast, Coroutine
 from tqdm.autonotebook import tqdm
 
-
-def read_contents_from_file(
-    file_path: str | Path,
-    binary_mode: bool = False,
-) -> str:
-    """Reads and returns contents of file"""
-    try:
-        if binary_mode:
-            with open(file_path, "rb") as file:
-                return file.read()
-        else:
-            with open(file_path) as file:
-                return file.read()
-    except FileNotFoundError:
-        print(f"File {file_path} not found.")
-        return ""
+from pydantic import BaseModel, GetCoreSchemaHandler, TypeAdapter, create_model
+from pydantic.fields import FieldInfo
+from pydantic_core import core_schema
 
 
-async def asyncio_gather_with_pbar(
-    *corouts: Coroutine[Any, Any, Any],
-    no_tqdm: bool = False,
-    desc: str | None = None,
-) -> list[Any]:
-    pbar = tqdm(total=len(corouts), desc=desc, disable=no_tqdm)
+logger = getLogger(__name__)
 
-    async def run_and_update(coro: Coroutine[Any, Any, Any]) -> Any:
-        result = await coro
-        pbar.update(1)
-        return result
 
-    wrapped_tasks = [run_and_update(c) for c in corouts]
-    results = await asyncio.gather(*wrapped_tasks)
-    pbar.close()
+def merge_pydantic_models(*models: type[BaseModel]) -> type[BaseModel]:
+    fields_dict: dict[str, FieldInfo] = {}
+    for model in models:
+        for field_name, field_info in model.model_fields.items():
+            if field_name in fields_dict:
+                raise ValueError(
+                    f"Field conflict detected: '{field_name}' exists in multiple models"
+                )
+            fields_dict[field_name] = field_info
 
-    return results
+    return create_model("MergedModel", __module__=__name__, **fields_dict)  # type: ignore
 
 
-def get_timestamp() -> str:
-    return datetime.now().strftime("%Y%m%d_%H%M%S")
+def filter_fields(data: dict[str, Any], model: type[BaseModel]) -> dict[str, Any]:
+    return {key: data[key] for key in model.model_fields if key in data}
 
 
 def read_txt(file_path: str) -> str:
@@ -73,26 +55,32 @@ def format_json_string(text: str) -> str:
                 pass
         i += 1
 
-    return ""
+    return text
 
 
-def read_json_string(json_str: str) -> dict[str, Any] | list[Any]:
+def read_json_string(
+    json_str: str, return_none_on_failure: bool = False
+) -> dict[str, Any] | list[Any] | None:
     try:
         json_response = ast.literal_eval(json_str)
     except (ValueError, SyntaxError):
         try:
             json_response = json.loads(json_str)
         except json.JSONDecodeError as exc:
+            if return_none_on_failure:
+                return None
             raise ValueError(
                 "Invalid JSON - Both ast.literal_eval and json.loads "
                 f"failed to parse the following response:\n{json_str}"
             ) from exc
 
-    return json_response  # type: ignore
+    return json_response
 
 
-def extract_json(json_str: str) -> dict[str, Any] | list[Any]:
-    return read_json_string(format_json_string(json_str))
+def extract_json(
+    json_str: str, return_none_on_failure: bool = False
+) -> dict[str, Any] | list[Any] | None:
+    return read_json_string(format_json_string(json_str), return_none_on_failure)
 
 
 def extract_xml_list(text: str) -> list[str]:
@@ -105,32 +93,43 @@ def extract_xml_list(text: str) -> list[str]:
     return chunks
 
 
-def get_prompt(prompt_text: str | None, prompt_path: str | Path | None) -> str | None:
-    if prompt_text is None:
-        prompt = (
-            read_contents_from_file(prompt_path) if prompt_path is not None else None
-        )
-    else:
-        prompt = prompt_text
-
-    return prompt
-
-
-def merge_pydantic_models(*models: type[BaseModel]) -> type[BaseModel]:
-    fields_dict: dict[str, FieldInfo] = {}
-    for model in models:
-        for field_name, field_info in model.model_fields.items():
-            if field_name in fields_dict:
-                raise ValueError(
-                    f"Field conflict detected: '{field_name}' exists in multiple models"
-                )
-            fields_dict[field_name] = field_info
-
-    return create_model("MergedModel", __module__=__name__, **fields_dict)  # type: ignore
+def make_conditional_parsed_output_type(
+    response_format: type, marker: str = "<DONE>"
+) -> type:
+    class ParsedOutput:
+        """
+        * Accepts any **str**.
+        * If the string contains `marker`, it must contain a valid JSON for
+        `response_format` → we return that a response_format instance.
+        * Otherwise we leave the string untouched.
+        """
+
+        @classmethod
+        def __get_pydantic_core_schema__(
+            cls,
+            _source_type: Any,
+            _handler: GetCoreSchemaHandler,
+        ) -> core_schema.CoreSchema:
+            def validator(v: Any) -> Any:
+                if isinstance(v, str) and marker in v:
+                    v_json_str = format_json_string(v)
+                    response_format_adapter = TypeAdapter[Any](response_format)
+
+                    return response_format_adapter.validate_json(v_json_str)
+
+                return v
+
+            return core_schema.no_info_after_validator_function(
+                validator, core_schema.any_schema()
+            )
 
+        @classmethod
+        def __get_pydantic_json_schema__(
+            cls, core_schema: core_schema.CoreSchema, handler: GetCoreSchemaHandler
+        ):
+            return handler(core_schema)
 
-def filter_fields(data: dict[str, Any], model: type[BaseModel]) -> dict[str, Any]:
-    return {key: data[key] for key in model.model_fields if key in data}
+    return ParsedOutput
 
 
 T = TypeVar("T", bound=Callable[..., Any])
@@ -149,3 +148,54 @@ def forbid_state_change(method: T) -> T:
         return result
 
     return cast("T", wrapper)
+
+
+def read_contents_from_file(
+    file_path: str | Path,
+    binary_mode: bool = False,
+) -> str | bytes:
+    """Reads and returns contents of file"""
+    try:
+        if binary_mode:
+            with open(file_path, "rb") as file:
+                return file.read()
+        else:
+            with open(file_path) as file:
+                return file.read()
+    except FileNotFoundError:
+        logger.error(f"File {file_path} not found.")
+        return ""
+
+
+def get_prompt(prompt_text: str | None, prompt_path: str | Path | None) -> str | None:
+    if prompt_text is None:
+        prompt = (
+            read_contents_from_file(prompt_path) if prompt_path is not None else None
+        )
+    else:
+        prompt = prompt_text
+
+    return prompt  # type: ignore[assignment]
+
+
+async def asyncio_gather_with_pbar(
+    *corouts: Coroutine[Any, Any, Any],
+    no_tqdm: bool = False,
+    desc: str | None = None,
+) -> list[Any]:
+    pbar = tqdm(total=len(corouts), desc=desc, disable=no_tqdm)
+
+    async def run_and_update(coro: Coroutine[Any, Any, Any]) -> Any:
+        result = await coro
+        pbar.update(1)
+        return result
+
+    wrapped_tasks = [run_and_update(c) for c in corouts]
+    results = await asyncio.gather(*wrapped_tasks)
+    pbar.close()
+
+    return results
+
+
+def get_timestamp() -> str:
+    return datetime.now().strftime("%Y%m%d_%H%M%S")

{grasp_agents-0.1.14.dist-info → grasp_agents-0.1.16.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: grasp_agents
-Version: 0.1.14
+Version: 0.1.16
 Summary: Grasp Agents Library
 License-File: LICENSE.md
-Requires-Python: <3.12,>=3.11.4
+Requires-Python: <4,>=3.11.4
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: httpx<1,>=0.27.0
 Requires-Dist: openai<2,>=1.68.2
+Requires-Dist: pydantic>=2
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: tenacity>=9.1.2
 Requires-Dist: termcolor<3,>=2.4.0
@@ -53,8 +54,6 @@ Description-Content-Type: text/markdown
 
 ## Quickstart & Installation Variants (UV Package manager)
 
-### Option 1: UV Package Manager Project
-
 > **Note:** You can check this sample project code in the [src/grasp_agents/examples/demo/uv](src/grasp_agents/examples/demo/uv) folder. Feel free to copy and paste the code from there to a separate project. There are also [examples](src/grasp_agents/examples/demo/) for other package managers.
 
 #### 1. Prerequisites

{grasp_agents-0.1.14.dist-info → grasp_agents-0.1.16.dist-info}/RECORD

@@ -1,44 +1,44 @@
-grasp_agents/agent_message.py,sha256=atYrmIVT-1wkLUM79YnqcRVy_J7Vwsj-9KCXFEoI0tc,944
+grasp_agents/agent_message.py,sha256=Z-czIHNSe7eAo5r6q2Zu10HFpUjQjVbayyglGyyj4Lw,911
 grasp_agents/agent_message_pool.py,sha256=4O4xz-aZ_I5m3iLAUiMAQcVn5AGRP4daUM8XME03Xsw,3250
-grasp_agents/base_agent.py,sha256=Zf7lL-0iYse1hKTfgWYCCO8Va-8wKliougW6Nmd2RG4,1876
-grasp_agents/cloud_llm.py,sha256=V1TN_xGTQ1uN4RVn_6bfYBEjnhxRCBHac60FFtCSawI,11677
-grasp_agents/comm_agent.py,sha256=x1x6lE23F4iitofKlDgmXTT-aNt6L-sR8wC5L9DRCag,7748
+grasp_agents/base_agent.py,sha256=4mNMyWdt9MTzg64JhrVjcU_FSYDj0ED_AKpRZXCRVb4,1870
+grasp_agents/cloud_llm.py,sha256=q72bDyC9bxQdiO552LiOYr58B9T3bMAJu0TGUZH4Lfk,13016
+grasp_agents/comm_agent.py,sha256=ukkT0zXgE8-yt63fyi3MQ_3Q0QjwIDHKz4MbHt9FBxw,7323
 grasp_agents/costs_dict.yaml,sha256=EW6XxRXLZobMwQEEiUNYALbDzfbZFb2zEVCaTSAqYjw,2334
 grasp_agents/grasp_logging.py,sha256=H1GYhXdQvVkmauFDZ-KDwvVmPQHZUUm9sRqX_ObK2xI,1111
 grasp_agents/http_client.py,sha256=KZva2MjJjuI5ohUeU8RdTAImUnQYaqBrV2jDH8smbJw,738
-grasp_agents/llm.py,sha256=fks_mGkg2vgPGsJGr6rD6mN-IMgbYab_nA2qj3A3ADQ,2987
-grasp_agents/llm_agent.py,sha256=9Z8qxOM4Y7oTBEi53zt8BqmAJIBqtwCGNxUfru458Xk,11997
+grasp_agents/llm.py,sha256=RZY25UNJEdPUmqOHifUrrQTgfoDCAVtZN9WQvvxnLC4,3004
+grasp_agents/llm_agent.py,sha256=_D16rA8LDhALZKYYuWxB-E75g3uBgzM04EcJyuRMKZA,12619
 grasp_agents/llm_agent_state.py,sha256=91K1-8Uodbe-t_I6nu0xBzHfQjssZYCHjMuDbu5aCr0,2327
-grasp_agents/memory.py,sha256=7YkZKQHuXAfQlGqLoXdt6YZmgSj3EWVtT72s_v84ixc,5808
+grasp_agents/memory.py,sha256=X1YtVX8XxP5KnGPMW8BqjID8QK4hTG2obxoyhnnZ4pU,5575
 grasp_agents/printer.py,sha256=Jk6OJExio53gbKBod5Dd8Y3CWYrVb4K5q4UJ8i9cQvo,5024
 grasp_agents/prompt_builder.py,sha256=rYVIY4adJwBitjrTYvpEh5x8C7cLbIiXxT1F-vQuvEM,7393
 grasp_agents/run_context.py,sha256=hyETO3-p0azPFws75kX6rrUDLf58Ar6jmyt6TQ5Po78,2589
-grasp_agents/tool_orchestrator.py,sha256=d7gOVqcki3qNC_UFvAyLO8iirGwrfzs50bQQrUF-43E,5513
+grasp_agents/tool_orchestrator.py,sha256=6VX8FGYeUHiSt9GpUjOga7KGP55Kzs1jEiNcOZysIAo,5501
 grasp_agents/usage_tracker.py,sha256=5YuN6hpg6HASdg-hOylgWzhCiORmDMnZuQtbISfhm_4,3378
-grasp_agents/utils.py,sha256=9newohaDSRuoUwSdrlox8RX3bI40MRTJyjT2S1MZzmE,4246
+grasp_agents/utils.py,sha256=tacUTUnPqz8qUvJxGpGhcdXOyvZJOzfblCrtzqfkCj8,5870
 grasp_agents/data_retrieval/__init__.py,sha256=KRgtF_E7R3YfA2cpYcFcZ7wycV0pWVJ0xRQC7YhiIEQ,158
 grasp_agents/data_retrieval/rate_limiter_chunked.py,sha256=NPqYrWwKTx1lim_zlhWar5wDwFz1cA-b6JOzT10kOtE,5843
 grasp_agents/data_retrieval/types.py,sha256=JbLYJC-gmzcHH_4-YNTz9IcIwVpcpDyDGvljxNznf5k,1389
 grasp_agents/data_retrieval/utils.py,sha256=D3Bkq6-9gF7ubearjZwZaTt_u2-sM3JDlGQD9HmJ3rQ,1917
 grasp_agents/openai/__init__.py,sha256=qN8HMAatSJKOsA6v-JwakMYguwkswCVHqrmK1gFy9wI,3096
-grasp_agents/openai/completion_converters.py,sha256=YvborvhN3_tACBBKXfOkx2NsTo6vqvNoPse_PqOSKUo,1774
+grasp_agents/openai/completion_converters.py,sha256=lX9h1kaGAo5ttsl-4V7l4x8IpjxJaJJtyU2cKu3-EOc,1871
 grasp_agents/openai/content_converters.py,sha256=6GI0D7xJalzsiawAJOyCUzTJTo0NQdpv87YKmfN0LYQ,2631
-grasp_agents/openai/converters.py,sha256=7O_K4MAW1CxwrF0vnA_MhrqwSeBx5eri8zADr-rzNuM,5346
-grasp_agents/openai/message_converters.py,sha256=IJwt7nd_YRe_Cw0mk8Szi6_Ys30KVgCFSFv_pp60SQk,4714
-grasp_agents/openai/openai_llm.py,sha256=A7ubei4pCR0g3mUk-0k-Anu5KBPmvNJnI3FSgIuKggk,6212
-grasp_agents/openai/tool_converters.py,sha256=MKprfNMorVNNUVorFe77yWNSOcYtMauUJtpXpeF4AH4,1033
+grasp_agents/openai/converters.py,sha256=DBXBxow9oRG6pc8inpZBLiuUqHzVfpscmHFpN9bAdvc,5276
+grasp_agents/openai/message_converters.py,sha256=KjF6FbXzwlWdM-1YT3cswUV-74sjiwOhLFPMY4sJ5Xk,4593
+grasp_agents/openai/openai_llm.py,sha256=rHeix_lSH8mogPfHjgrsaYMrHBMt5q9k-4x33_-zwyA,6149
+grasp_agents/openai/tool_converters.py,sha256=KhWRETkjhjocISUo_HBZ8QfBiyTOoC5WurPNAR4BYxc,1027
 grasp_agents/typing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 grasp_agents/typing/completion.py,sha256=_KDLx3Gtz7o-pEZrvAFgCZwDmkr2oQkxrL-2LSXHHsw,657
 grasp_agents/typing/content.py,sha256=13nLNZqZgtpo9sM0vCRQmZ4bQjjZqUSElMQOwjL7bO8,3651
-grasp_agents/typing/converters.py,sha256=VM_kVEf11qYzTg_3Z9Tbu8o-xndt3Cb90BjE3Daehes,3117
-grasp_agents/typing/io.py,sha256=w2J71_-AaRFh1F3OEPXzAeMyHOKgG4l34A_scqU4GCg,813
-grasp_agents/typing/message.py,sha256=1-QF14NZcPcDive_oVM6u12QHlt8q7NHuCY4kuFULbY,3725
-grasp_agents/typing/tool.py,sha256=rLw8W8RIGQ5Hk9B0Yk9I8dN3wU2-D1lL54z_qiOlPRQ,1362
+grasp_agents/typing/converters.py,sha256=EbGur_Ngx-wINfyOEHa7JqmKnMAxZ5vJjhAPoqBf_AM,3048
+grasp_agents/typing/io.py,sha256=M294tNROa9gJ_I38c9pLekEbUK2p3qirYdE_QGpuw1c,624
+grasp_agents/typing/message.py,sha256=oCpqD_CV2Da-M-l-e5liFJSwK8267fxfcU68LIc7C1E,3801
+grasp_agents/typing/tool.py,sha256=t40vr3ljQY_Qx0f0KZIc151bYlHUF7Bf7JfOkiJOi2c,1657
 grasp_agents/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 grasp_agents/workflow/looped_agent.py,sha256=YBOgOIvy3_NwKvEoGgzQJ2fY9SNG66MQk6obSBGWvCc,3896
 grasp_agents/workflow/sequential_agent.py,sha256=yDt2nA-b1leVByD8jsKrWD6bHe0o9z33jrOJGOLwbyk,2004
 grasp_agents/workflow/workflow_agent.py,sha256=9U94IQ39Vb1W_5u8aoqHb65ikdarEhEJkexDz8xwHD4,2294
-grasp_agents-0.1.14.dist-info/METADATA,sha256=oWvgd41nqe41sfMS5ADwJndfNDetI1K2uI_kVcjOcyA,4272
-grasp_agents-0.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-grasp_agents-0.1.14.dist-info/licenses/LICENSE.md,sha256=Kfeo0gdlLS6tLQiWwO9UWhjp9-f93a5kShSiBp2FG-c,1201
-grasp_agents-0.1.14.dist-info/RECORD,,
+grasp_agents-0.1.16.dist-info/METADATA,sha256=s8QElgMOrmr0ZXlfWgRvPbz-kyfDtUBPnCu2EPCUsBY,4254
+grasp_agents-0.1.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+grasp_agents-0.1.16.dist-info/licenses/LICENSE.md,sha256=Kfeo0gdlLS6tLQiWwO9UWhjp9-f93a5kShSiBp2FG-c,1201
+grasp_agents-0.1.16.dist-info/RECORD,,