grasp_agents 0.2.11__py3-none-any.whl → 0.3.1__py3-none-any.whl

grasp_agents/generics_utils.py

@@ -148,12 +148,20 @@ class AutoInstanceAttributesMixin:
         return resolved
 
     def _set_resolved_generic_instance_attributes(self) -> None:
-        for name, typ in getattr(
+        attr_names = self._generic_arg_to_instance_attr_map.values()
+        resolved_attr_types = getattr(
             self.__class__, "_resolved_instance_attr_types", {}
-        ).items():
-            _typ = None if typ is type(None) else typ
-            pyd_private = getattr(self, "__pydantic_private__", {})
-            if name in pyd_private:
-                pyd_private[name] = _typ
+        )
+        pyd_private = getattr(self, "__pydantic_private__", {})
+
+        for attr_name in attr_names:
+            if attr_name in resolved_attr_types:
+                attr_type = resolved_attr_types[attr_name]
+                # attr_type = None if _attr_type is type(None) else _attr_type
+            else:
+                attr_type = Any
+
+            if attr_name in pyd_private:
+                pyd_private[attr_name] = attr_type
             else:
-                setattr(self, name, _typ)
+                setattr(self, attr_name, attr_type)

grasp_agents/llm.py

@@ -7,31 +7,37 @@ from uuid import uuid4
 from pydantic import BaseModel, TypeAdapter
 from typing_extensions import TypedDict
 
-from .memory import MessageHistory
-from .typing.completion import Completion, CompletionChunk
+from grasp_agents.utils import validate_obj_from_json_or_py_string
+
+from .message_history import MessageHistory
+from .typing.completion import Completion
 from .typing.converters import Converters
-from .typing.message import AssistantMessage, Conversation
+from .typing.events import CompletionChunkEvent, CompletionEvent
+from .typing.message import Messages
 from .typing.tool import BaseTool, ToolChoice
 
 logger = logging.getLogger(__name__)
 
 
-class LLMSettings(TypedDict):
-    pass
+class LLMSettings(TypedDict, total=False):
+    max_completion_tokens: int | None
+    temperature: float | None
+    top_p: float | None
+    seed: int | None
 
 
-SettingsT = TypeVar("SettingsT", bound=LLMSettings, covariant=True)  # noqa: PLC0105
-ConvertT = TypeVar("ConvertT", bound=Converters, covariant=True)  # noqa: PLC0105
+SettingsT_co = TypeVar("SettingsT_co", bound=LLMSettings, covariant=True)
+ConvertT_co = TypeVar("ConvertT_co", bound=Converters, covariant=True)
 
 
-class LLM(ABC, Generic[SettingsT, ConvertT]):
+class LLM(ABC, Generic[SettingsT_co, ConvertT_co]):
     @abstractmethod
     def __init__(
         self,
-        converters: ConvertT,
+        converters: ConvertT_co,
         model_name: str | None = None,
         model_id: str | None = None,
-        llm_settings: SettingsT | None = None,
+        llm_settings: SettingsT_co | None = None,
         tools: list[BaseTool[BaseModel, Any, Any]] | None = None,
         response_format: type | Mapping[str, type] | None = None,
         **kwargs: Any,
@@ -42,20 +48,18 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         self._model_id = model_id or str(uuid4())[:8]
         self._model_name = model_name
         self._tools = {t.name: t for t in tools} if tools else None
-        self._llm_settings: SettingsT = llm_settings or cast("SettingsT", {})
+        self._llm_settings: SettingsT_co = llm_settings or cast("SettingsT_co", {})
 
         self._response_format = response_format
-        self._response_format_pyd: (
-            TypeAdapter[Any] | Mapping[str, TypeAdapter[Any]] | None
-        )
+        self._response_format_adapter: TypeAdapter[Any] | Mapping[str, TypeAdapter[Any]]
         if isinstance(response_format, type):
-            self._response_format_pyd = TypeAdapter(response_format)
+            self._response_format_adapter = TypeAdapter(response_format)
         elif isinstance(response_format, Mapping):
-            self._response_format_pyd = {
+            self._response_format_adapter = {
                 k: TypeAdapter(v) for k, v in response_format.items()
             }
         else:
-            self._response_format_pyd = None
+            self._response_format_adapter = TypeAdapter(Any)
 
     @property
     def model_id(self) -> str:
@@ -66,7 +70,7 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         return self._model_name
 
     @property
-    def llm_settings(self) -> SettingsT:
+    def llm_settings(self) -> SettingsT_co:
         return self._llm_settings
 
     @property
@@ -82,7 +86,9 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         self._tools = {t.name: t for t in tools} if tools else None
 
     @response_format.setter
-    def response_format(self, response_format: type | None) -> None:
+    def response_format(
+        self, response_format: type | Mapping[str, type] | None
+    ) -> None:
         self._response_format = response_format
 
     def __repr__(self) -> str:
@@ -91,32 +97,55 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
             f"model_name={self._model_name})"
         )
 
+    def _validate_completion(self, completion: Completion) -> None:
+        for message in completion.messages:
+            if not message.tool_calls:
+                validate_obj_from_json_or_py_string(
+                    message.content or "",
+                    adapter=self._response_format_adapter,
+                    from_substring=True,
+                )
+
+    def _validate_tool_calls(self, completion: Completion) -> None:
+        for message in completion.messages:
+            if message.tool_calls:
+                for tool_call in message.tool_calls:
+                    tool_name = tool_call.tool_name
+                    tool_arguments = tool_call.tool_arguments
+
+                    available_tool_names = list(self.tools) if self.tools else []
+                    if tool_name not in available_tool_names or not self.tools:
+                        raise ValueError(
+                            f"Tool '{tool_name}' is not available in the LLM tools "
+                            f"(available: {available_tool_names}"
+                        )
+                    tool = self.tools[tool_name]
+                    validate_obj_from_json_or_py_string(
+                        tool_arguments, adapter=TypeAdapter(tool.in_type)
+                    )
+
     @abstractmethod
     async def generate_completion(
         self,
-        conversation: Conversation,
+        conversation: Messages,
         *,
         tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
+        n_choices: int | None = None,
     ) -> Completion:
         pass
 
     @abstractmethod
     async def generate_completion_stream(
         self,
-        conversation: Conversation,
+        conversation: Messages,
         *,
         tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
-    ) -> AsyncIterator[CompletionChunk]:
+        n_choices: int | None = None,
+    ) -> AsyncIterator[CompletionChunkEvent | CompletionEvent]:
         pass
 
     @abstractmethod
-    async def generate_message_batch(
-        self,
-        message_history: MessageHistory,
-        *,
-        tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
-    ) -> Sequence[AssistantMessage]:
+    async def generate_completion_batch(
+        self, message_history: MessageHistory, *, tool_choice: ToolChoice | None = None
+    ) -> Sequence[Completion]:
         pass