hammad-python 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

hammad/genai/{language_models → models/language/types}/language_model_response.py

@@ -1,32 +1,38 @@
 """hammad.genai.language_models.language_model_response"""
 
-from typing import List, TypeVar, Generic, TYPE_CHECKING, Optional, Any, Dict, Union
-from pydantic import BaseModel, ConfigDict
-
-if TYPE_CHECKING:
-    try:
-        import litellm
-        from openai.types.chat import (
-            ChatCompletionContentPartParam,
-            ChatCompletionMessageParam,
-        )
-    except ImportError:
-        ChatCompletionContentPartParam = Any
-        ChatCompletionMessageParam = Any
-
+from __future__ import annotations
+
+from typing import (
+    List,
+    TypeVar,
+    Optional,
+    Any,
+    Dict,
+    Union,
+    Literal,
+)
+
+from ...model_provider import litellm
+from ....types.base import BaseGenAIModelResponse
+from openai.types.chat import (
+    ChatCompletionContentPartParam,
+    ChatCompletionMessageParam,
+    ChatCompletionMessageToolCall,
+)
 
 __all__ = [
     "LanguageModelResponse",
 ]
 
+
 T = TypeVar("T")
 
 
-class LanguageModelResponse(BaseModel, Generic[T]):
+class LanguageModelResponse(BaseGenAIModelResponse[T]):
     """A response generated by a language model. This response is unified
     to represent both standard completions as well as structured outputs."""
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    type: Literal["language_model"] = "language_model"
 
     model: str
     """The model that generated this response."""
@@ -56,75 +62,64 @@ class LanguageModelResponse(BaseModel, Generic[T]):
     was generated by the model when it refused to generate the completion."""
 
     def get_content(
-        self,
-        choice: int = 0
+        self, choice: int = 0
     ) -> Union[str, List["ChatCompletionContentPartParam"], None]:
         """The 'raw' message content generated by the language model, this
         can be either a string, a list of content parts, or `None`."""
 
         if not self.completion or not self.completion.choices:
             return None
-        
+
         if choice >= len(self.completion.choices):
             return None
-            
+
         return self.completion.choices[choice].message.content
 
     def get_tool_calls(
-        self,
-        *,
-        name: Optional[str] = None,
-        id: Optional[str] = None,
-        choice: int = 0
-    ) -> Optional[List["litellm.ChatCompletionMessageToolCall"]]:
+        self, *, name: Optional[str] = None, id: Optional[str] = None, choice: int = 0
+    ) -> Optional[List["ChatCompletionMessageToolCall"]]:
         """The tool calls generated by the language model, this is a list of
         `ChatCompletionMessageToolCall` objects. Optionally can be filtered
         by name or ID to return specific tool calls.
-        
+
         NOTE: Only one of `name` or `id` can be provided."""
         if not self.completion or not self.completion.choices:
             return None
-        
+
         if choice >= len(self.completion.choices):
             return None
-        
+
         tool_calls = self.completion.choices[choice].message.tool_calls
         if not tool_calls:
             return None
-        
+
         # Filter by name or id if provided
         if name is not None and id is not None:
             raise ValueError("Only one of 'name' or 'id' can be provided, not both")
-        
+
         if name is not None:
             return [call for call in tool_calls if call.function.name == name]
-        
+
         if id is not None:
             return [call for call in tool_calls if call.id == id]
-        
+
         return tool_calls
 
-    def has_tool_calls(
-        self,
-        name: Optional[str] = None,
-        choice: int = 0
-    ) -> bool:
+    def has_tool_calls(self, name: Optional[str] = None, choice: int = 0) -> bool:
         """Checks if the response has tool calls, optionally filtered by name.
         If `name` is provided, it will check if the tool call with that name
         exists in the response."""
         if not self.completion or not self.completion.choices:
             return False
-        
+
         tool_calls = self.get_tool_calls(name=name, choice=choice)
         return tool_calls is not None and len(tool_calls) > 0
 
     def get_tool_call_parameters(
-        self, 
-        tool: Optional[str] = None,
-        choice: int = 0
+        self, tool: Optional[str] = None, choice: int = 0
     ) -> Optional[Dict[str, Any]]:
-        """Returns the generated parameters for a tool call within a response. 
-        If the response has multiple tool calls, and no tool is specified, 
+        """Returns the generated parameters for a tool call within a response.
+        If the response has multiple tool calls, and no tool is specified,
         an error will be raised.
 
         Args:
@@ -148,62 +143,60 @@ class LanguageModelResponse(BaseModel, Generic[T]):
         for tool_call in tool_calls:
             if tool_call.function.name == tool:
                 import json
+
                 return json.loads(tool_call.function.arguments)
         return None
 
     def to_message(
-        self,
-        format_tool_calls: bool = False,
-        choice: int = 0
+        self, format_tool_calls: bool = False, choice: int = 0
     ) -> "ChatCompletionMessageParam":
         """Converts the LanguageModelResponse to a Chat Completions
         message object.
-        
+
         If the `format_tool_calls` parameter is True, the tool calls
         will be cleanly formatted and added to the message content
         with something similar to:
-            
+
         'I called the function `get_weather` with the following arguments:
         {arguments}'
         """
         if not self.completion or not self.completion.choices:
-            return {
-                "role": "assistant",
-                "content": ""
-            }
-        
+            return {"role": "assistant", "content": ""}
+
         if choice >= len(self.completion.choices):
-            return {
-                "role": "assistant", 
-                "content": ""
-            }
-        
+            return {"role": "assistant", "content": ""}
+
         choice_message = self.completion.choices[choice].message
-        
+
         # Base message structure
         message: "ChatCompletionMessageParam" = {
             "role": "assistant",
-            "content": choice_message.content or ""
+            "content": choice_message.content or "",
         }
-        
+
         # Add tool calls if they exist and format_tool_calls is False
         if choice_message.tool_calls and not format_tool_calls:
             message["tool_calls"] = choice_message.tool_calls
-        
+
         # Format tool calls into content if format_tool_calls is True
         elif choice_message.tool_calls and format_tool_calls:
             content_parts = []
             if choice_message.content:
                 content_parts.append(choice_message.content)
-            
+
             for tool_call in choice_message.tool_calls:
                 formatted_call = f"I called the function `{tool_call.function.name}` with the following arguments:\n{tool_call.function.arguments}"
                 content_parts.append(formatted_call)
-            
+
             message["content"] = "\n\n".join(content_parts)
-        
+
         return message
 
+    def to_content_part(self) -> "ChatCompletionContentPartParam":
+        """Converts the LanguageModelResponse to a Chat Completions
+        content part object."""
+        return {"type": "text", "text": self.content}
+
     def __str__(self) -> str:
         """Pretty prints the response object."""
         output = "LanguageModelResponse:"
@@ -216,4 +209,4 @@ class LanguageModelResponse(BaseModel, Generic[T]):
         output += f"\n\n>>> Model: {self.model}"
         output += f"\n>>> Tool Calls: {len(self.tool_calls) if self.tool_calls else 0}"
 
-        return output
+        return output

hammad/genai/{language_models → models/language/types}/language_model_response_chunk.py

@@ -1,23 +1,26 @@
 """hammad.genai.language_models.language_model_response_chunk"""
 
-from typing import TypeVar, Generic, Optional, Any
-from pydantic import BaseModel, ConfigDict
+from typing import TypeVar, Optional, Any, Literal
+
+from ....types.base import BaseGenAIModelEvent
 
 __all__ = [
     "LanguageModelResponseChunk",
 ]
 
+
 T = TypeVar("T")
 
 
-class LanguageModelResponseChunk(BaseModel, Generic[T]):
+class LanguageModelResponseChunk(BaseGenAIModelEvent[T]):
     """Represents a chunk of data from a language model response stream.
 
     This class unifies chunks from both LiteLLM and Instructor streaming,
     providing a consistent interface for processing streaming responses.
     """
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    type: Literal["language_model"] = "language_model"
+    """The type of the event, always `language_model`."""
 
     content: Optional[str] = None
     """The content delta for this chunk."""
@@ -50,4 +53,4 @@ class LanguageModelResponseChunk(BaseModel, Generic[T]):
         elif self.finish_reason:
             return f"LanguageModelResponseChunk(finish_reason={self.finish_reason})"
         else:
-            return "LanguageModelResponseChunk(empty)"
+            return "LanguageModelResponseChunk(empty)"

hammad/genai/models/language/types/language_model_settings.py

@@ -0,0 +1,89 @@
+"""hammad.genai.language_models.language_model_settings"""
+
+from typing import (
+    Any,
+    Dict,
+    List,
+    Union,
+    Type,
+    TypeVar,
+    TYPE_CHECKING,
+    Callable,
+    Optional,
+)
+import sys
+from pydantic import BaseModel, Field
+
+if sys.version_info >= (3, 12):
+    from typing import TypedDict, Required, NotRequired
+else:
+    from typing_extensions import TypedDict, Required, NotRequired
+
+if TYPE_CHECKING:
+    pass
+
+from .language_model_name import LanguageModelName
+from .language_model_instructor_mode import LanguageModelInstructorMode
+from ....types.base import BaseGenAIModelSettings
+
+__all__ = [
+    "LanguageModelSettings",
+    "LanguageModelProviderSettings",
+]
+
+
+T = TypeVar("T")
+
+
+class LanguageModelSettings(BaseGenAIModelSettings):
+    """Complete settings for language model requests."""
+
+    # Structured output settings
+    type: Optional[Type[T]] = None
+    instructor_mode: Optional[LanguageModelInstructorMode] = None
+    response_field_name: Optional[str] = None
+    response_field_instruction: Optional[str] = None
+    max_retries: Optional[int] = None
+    strict: Optional[bool] = None
+    validation_context: Optional[Dict[str, Any]] = None
+    context: Optional[Dict[str, Any]] = None
+
+    # Tool settings
+    tools: Optional[List[Any]] = None
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None
+    parallel_tool_calls: Optional[bool] = None
+    functions: Optional[List[Any]] = None
+    function_call: Optional[str] = None
+
+    # Streaming settings
+    stream: Optional[bool] = None
+    stream_options: Optional[Dict[str, Any]] = None
+
+    # Hook settings
+    completion_kwargs_hooks: Optional[List[Callable[..., None]]] = None
+    completion_response_hooks: Optional[List[Callable[..., None]]] = None
+    completion_error_hooks: Optional[List[Callable[..., None]]] = None
+    completion_last_attempt_hooks: Optional[List[Callable[..., None]]] = None
+    parse_error_hooks: Optional[List[Callable[..., None]]] = None
+
+    # Extended settings
+    timeout: Optional[Union[float, str]] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stop: Optional[str] = None
+    max_completion_tokens: Optional[int] = None
+    max_tokens: Optional[int] = None
+    modalities: Optional[List[Any]] = None
+    prediction: Optional[Any] = None
+    audio: Optional[Any] = None
+    presence_penalty: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    logit_bias: Optional[Dict[str, float]] = None
+    user: Optional[str] = None
+    reasoning_effort: Optional[str] = None
+    seed: Optional[int] = None
+    logprobs: Optional[bool] = None
+    top_logprobs: Optional[int] = None
+    thinking: Optional[Dict[str, Any]] = None
+    web_search_options: Optional[Dict[str, Any]] = None