grasp_agents 0.2.6__tar.gz → 0.2.8__tar.gz

{grasp_agents-0.2.6 → grasp_agents-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_agents
-Version: 0.2.6
+Version: 0.2.8
 Summary: Grasp Agents Library
 License-File: LICENSE.md
 Requires-Python: <4,>=3.11.4

{grasp_agents-0.2.6 → grasp_agents-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "grasp_agents"
-version = "0.2.6"
+version = "0.2.8"
 description = "Grasp Agents Library"
 readme = "README.md"
 requires-python = ">=3.11.4,<4"

{grasp_agents-0.2.6 → grasp_agents-0.2.8}/src/grasp_agents/cloud_llm.py

@@ -2,12 +2,12 @@ import fnmatch
 import logging
 import os
 from abc import abstractmethod
-from collections.abc import AsyncIterator, Sequence
+from collections.abc import AsyncIterator, Mapping, Sequence
 from copy import deepcopy
 from typing import Any, Generic, Literal
 
 import httpx
-from pydantic import BaseModel, TypeAdapter
+from pydantic import BaseModel
 from tenacity import (
     RetryCallState,
     retry,
@@ -104,7 +104,7 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
         llm_settings: SettingsT | None = None,
         model_id: str | None = None,
         tools: list[BaseTool[BaseModel, Any, Any]] | None = None,
-        response_format: type | None = None,
+        response_format: type | Mapping[str, type] | None = None,
         # Connection settings
         async_http_client_params: (
             dict[str, Any] | AsyncHTTPClientParams | None
@@ -148,9 +148,6 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
             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

{grasp_agents-0.2.6 → grasp_agents-0.2.8}/src/grasp_agents/llm.py

@@ -1,10 +1,10 @@
 import logging
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator, Sequence
+from collections.abc import AsyncIterator, Mapping, Sequence
 from typing import Any, Generic, TypeVar, cast
 from uuid import uuid4
 
-from pydantic import BaseModel
+from pydantic import BaseModel, TypeAdapter
 from typing_extensions import TypedDict
 
 from .memory import MessageHistory
@@ -33,7 +33,7 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         model_id: str | None = None,
         llm_settings: SettingsT | None = None,
         tools: list[BaseTool[BaseModel, Any, Any]] | None = None,
-        response_format: type | None = None,
+        response_format: type | Mapping[str, type] | None = None,
         **kwargs: Any,
     ) -> None:
         super().__init__()
@@ -42,9 +42,21 @@ 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._response_format = response_format
         self._llm_settings: SettingsT = llm_settings or cast("SettingsT", {})
 
+        self._response_format = response_format
+        self._response_format_pyd: (
+            TypeAdapter[Any] | Mapping[str, TypeAdapter[Any]] | None
+        )
+        if isinstance(response_format, type):
+            self._response_format_pyd = TypeAdapter(response_format)
+        elif isinstance(response_format, Mapping):
+            self._response_format_pyd = {
+                k: TypeAdapter(v) for k, v in response_format.items()
+            }
+        else:
+            self._response_format_pyd = None
+
     @property
     def model_id(self) -> str:
         return self._model_id
@@ -62,7 +74,7 @@ class LLM(ABC, Generic[SettingsT, ConvertT]):
         return self._tools
 
     @property
-    def response_format(self) -> type | None:
+    def response_format(self) -> type | Mapping[str, type] | None:
         return self._response_format
 
     @tools.setter

{grasp_agents-0.2.6 → grasp_agents-0.2.8}/src/grasp_agents/openai/message_converters.py

@@ -114,7 +114,7 @@ def to_api_assistant_message(
         tool_calls=api_tool_calls or [],
         refusal=message.refusal,
     )
-    if message.content is None and not api_tool_calls:
+    if message.content is None:
         # Some API providers return None in the generated content without errors,
         # even though None in the input content is not accepted.
         api_message["content"] = "<empty>"

{grasp_agents-0.2.6 → grasp_agents-0.2.8}/src/grasp_agents/utils.py

@@ -6,14 +6,9 @@ from collections.abc import Coroutine, Mapping
 from datetime import datetime
 from logging import getLogger
 from pathlib import Path
-from typing import Any, TypeVar
-
-from pydantic import (
-    GetCoreSchemaHandler,
-    TypeAdapter,
-    ValidationError,
-)
-from pydantic_core import core_schema
+from typing import Any, TypeVar, overload
+
+from pydantic import TypeAdapter, ValidationError
 from tqdm.autonotebook import tqdm
 
 logger = getLogger(__name__)
@@ -62,9 +57,37 @@ def parse_json_or_py_substring(
     )
 
 
+@overload
+def validate_obj_from_json_or_py_string(
+    s: str,
+    adapter: TypeAdapter[T],
+    from_substring: bool = False,
+) -> T: ...
+
+
+@overload
+def validate_obj_from_json_or_py_string(
+    s: str,
+    adapter: Mapping[str, TypeAdapter[T]],
+    from_substring: bool = False,
+) -> T | str: ...
+
+
 def validate_obj_from_json_or_py_string(
-    s: str, adapter: TypeAdapter[T], from_substring: bool = False
-) -> T:
+    s: str,
+    adapter: TypeAdapter[T] | Mapping[str, TypeAdapter[T]],
+    from_substring: bool = False,
+) -> T | str:
+    _selected_adapter: TypeAdapter[T] | None = None
+    if isinstance(adapter, Mapping):
+        for _marker, _adapter in adapter.items():
+            if _marker in s:
+                _selected_adapter = _adapter
+        if _selected_adapter is None:
+            return s
+    else:
+        _selected_adapter = adapter
+
     try:
         if from_substring:
             parsed = parse_json_or_py_substring(s, return_none_on_failure=True)
@@ -72,10 +95,11 @@ def validate_obj_from_json_or_py_string(
             parsed = parse_json_or_py_string(s, return_none_on_failure=True)
         if parsed is None:
             parsed = s
-        return adapter.validate_python(parsed)
+        return _selected_adapter.validate_python(parsed)
     except (json.JSONDecodeError, ValidationError) as exc:
         raise ValueError(
-            f"Invalid JSON or Python string:\n{s}\nExpected type: {adapter._type}",  # type: ignore[arg-type]
+            f"Invalid JSON or Python string:\n{s}\n"
+            f"Expected type: {_selected_adapter._type}",  # type: ignore[arg-type]
         ) from exc
 
 
@@ -89,64 +113,6 @@ def extract_xml_list(text: str) -> list[str]:
     return chunks
 
 
-def build_marker_json_parser_type(
-    marker_to_model: Mapping[str, type],
-) -> type:
-    """
-    Return a Pydantic-compatible *type* that, when given a **str**, searches for
-    the first marker substring and validates the JSON that follows with the
-    corresponding Pydantic model.
-
-    If no marker is found, the raw string is returned unchanged.
-
-    Example:
-    -------
-    >>> Todo = build_marker_json_parser_type({'```json': MyModel})
-    >>> Todo.validate('```json {"a": 1}')
-    MyModel(a=1)
-
-    """
-
-    class MarkerParsedOutput:
-        """String → (Model | str) parser generated by build_marker_json_parser_type."""
-
-        @classmethod
-        def __get_pydantic_core_schema__(
-            cls,
-            _source_type: Any,
-            _handler: GetCoreSchemaHandler,
-        ) -> core_schema.CoreSchema:
-            def _validate(value: Any) -> Any:
-                if not isinstance(value, str):
-                    raise TypeError("MarkerParsedOutput expects a string")
-
-                for marker, model in marker_to_model.items():
-                    if marker in value:
-                        adapter = TypeAdapter[Any](model)
-                        return validate_obj_from_json_or_py_string(
-                            value, adapter=adapter, from_substring=True
-                        )
-
-                return value
-
-            return core_schema.no_info_after_validator_function(
-                _validate, core_schema.any_schema()
-            )
-
-        @classmethod
-        def __get_pydantic_json_schema__(
-            cls,
-            schema: core_schema.CoreSchema,
-            handler: GetCoreSchemaHandler,
-        ):
-            return handler(schema)
-
-    unique_suffix = "_".join(sorted(marker_to_model))[:40]
-    MarkerParsedOutput.__name__ = f"MarkerParsedOutput_{unique_suffix}"
-
-    return MarkerParsedOutput
-
-
 def read_txt(file_path: str | Path, encoding: str = "utf-8") -> str:
     return Path(file_path).read_text(encoding=encoding)