promptbuilder 0.4.40__tar.gz → 0.4.42__tar.gz

{promptbuilder-0.4.40/promptbuilder.egg-info → promptbuilder-0.4.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: promptbuilder
-Version: 0.4.40
+Version: 0.4.42
 Summary: Library for building prompts for LLMs
 Home-page: https://github.com/kapulkin/promptbuilder
 Author: Kapulkin Stanislav

{promptbuilder-0.4.40 → promptbuilder-0.4.42}/promptbuilder/llm_client/base_client.py

@@ -58,7 +58,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         return self.provider + ":" + self.model
     
     @staticmethod
-    def as_json(text: str) -> Json:
+    def as_json(text: str, raise_on_error: bool = True) -> Json:
         # Remove markdown code block formatting if present
         text = text.strip()
                 
@@ -72,7 +72,9 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         try:
             return json.loads(text, strict=False)
         except json.JSONDecodeError as e:
-            raise ValueError(f"Failed to parse LLM response as JSON:\n{text}")
+            if raise_on_error:
+                raise ValueError(f"Failed to parse LLM response as JSON:\n{text}")
+            return None
 
     def create(
         self,
@@ -109,7 +111,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         finish_reason = response.candidates[0].finish_reason.value if response.candidates and response.candidates[0].finish_reason else None
         if autocomplete:
             while response.candidates and finish_reason == FinishReason.MAX_TOKENS.value:
-                BaseLLMClient._append_generated_part(messages, response)
+                BaseLLMClient._append_generated_part(messages, response, result_type)
 
                 response = self._create(
                     messages=messages,
@@ -126,7 +128,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
                 if max_tokens is not None and total_count >= max_tokens:
                     break
             if response.candidates and response.candidates[0].content:
-                appended_message = BaseLLMClient._append_generated_part(messages, response)
+                appended_message = BaseLLMClient._append_generated_part(messages, response, result_type)
                 if appended_message is not None:
                     response.candidates[0].content = appended_message
         return response
@@ -219,6 +221,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         tools: list[Tool] | None = None,
         tool_choice_mode: Literal["ANY", "NONE"] = "NONE",
         autocomplete: bool = False,
+        raise_on_json_error: bool = True,
     ):
         if result_type == "tools":
             response = self.create(
@@ -254,7 +257,10 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
             return response.text
         else:
             if result_type == "json" and response.parsed is None:
-                response.parsed = BaseLLMClient.as_json(response.text)
+                text = response.text
+                response.parsed = BaseLLMClient.as_json(text, raise_on_json_error)
+                if response.parsed is None:
+                    return text
             return response.parsed
     
     @staticmethod
@@ -280,7 +286,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
                 return None, None
 
     @staticmethod
-    def _append_to_message(message: Content, text: str, is_thought: bool):
+    def _append_to_message(message: Content, text: str, is_thought: bool | None):
         if message.parts and message.parts[-1].text is not None and message.parts[-1].thought == is_thought:
             message.parts[-1].text += text
         else:
@@ -289,14 +295,17 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
             message.parts.append(Part(text=text, thought=is_thought))
 
     @staticmethod
-    def _append_generated_part(messages: list[Content], response: Response) -> Content | None:
+    def _append_generated_part(messages: list[Content], response: Response, result_type: ResultType = None) -> Content | None:
         response_text, is_thought = BaseLLMClient._responce_to_text(response)
         if response_text is None:
             return None
         
         if len(messages) > 0 and messages[-1].role == "model":
             message_to_append = messages[-1]
-            BaseLLMClient._append_to_message(message_to_append, response_text, is_thought)
+            if result_type is None or result_type == "str":
+                BaseLLMClient._append_to_message(message_to_append, response_text, is_thought)
+            else: # json, pydantic model
+                message_to_append.parts = [Part(text=response_text, thought=is_thought)]
         else:
             messages.append(Content(parts=[Part(text=response_text, thought=is_thought)], role="model"))
         return messages[-1]
@@ -527,7 +536,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         finish_reason = response.candidates[0].finish_reason.value if response.candidates and response.candidates[0].finish_reason else None
         if autocomplete:
             while response.candidates and finish_reason == FinishReason.MAX_TOKENS.value:
-                BaseLLMClient._append_generated_part(messages, response)
+                BaseLLMClient._append_generated_part(messages, response, result_type)
 
                 response = await self._create(
                     messages=messages,
@@ -544,7 +553,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
                 if max_tokens is not None and total_count >= max_tokens:
                     break
             if response.candidates and response.candidates[0].content:
-                appended_message = BaseLLMClient._append_generated_part(messages, response)
+                appended_message = BaseLLMClient._append_generated_part(messages, response, result_type)
                 if appended_message is not None:
                     response.candidates[0].content = appended_message
         return response
@@ -595,6 +604,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         tools: None = None,
         tool_choice_mode: Literal["NONE"] = "NONE",
         autocomplete: bool = False,
+        raise_on_json_error: bool = True,
     ) -> Json: ...
     @overload
     async def create_value(
@@ -637,6 +647,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         tools: list[Tool] | None = None,
         tool_choice_mode: Literal["ANY", "NONE"] = "NONE",
         autocomplete: bool = False,
+        raise_on_json_error: bool = True,
     ):
         if result_type == "tools":
             response = await self._create(
@@ -671,7 +682,10 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
             return response.text
         else:
             if result_type == "json" and response.parsed is None:
-                response.parsed = BaseLLMClient.as_json(response.text)
+                text = response.text
+                response.parsed = BaseLLMClient.as_json(text, raise_on_json_error)
+                if response.parsed is None:
+                    return text
             return response.parsed
     
     @logfire_decorators.create_stream_async

{promptbuilder-0.4.40 → promptbuilder-0.4.42}/promptbuilder/llm_client/google_client.py

@@ -7,7 +7,7 @@ from tenacity import RetryError
 from google.genai import Client, types
 
 from promptbuilder.llm_client.base_client import BaseLLMClient, BaseLLMClientAsync, ResultType
-from promptbuilder.llm_client.types import Response, Content, Part, ThinkingConfig, Tool, ToolConfig, Model
+from promptbuilder.llm_client.types import Response, Content, Part, ThinkingConfig, Tool, ToolConfig, Model, FunctionCall, FunctionResponse, Blob, FunctionDeclaration, Schema, FunctionCallingConfig, PartLike
 from promptbuilder.llm_client.config import DecoratorConfigs
 from promptbuilder.llm_client.utils import inherited_decorator
 from promptbuilder.llm_client.exceptions import APIError
@@ -16,6 +16,161 @@ from promptbuilder.llm_client.exceptions import APIError
 P = ParamSpec("P")
 
 
+def _convert_blob_to_genai(blob: Blob | None) -> types.Blob | None:
+    """Convert custom Blob to google.genai.types.Blob"""
+    if blob is None:
+        return None
+    return types.Blob.model_construct(**blob.__dict__)
+
+
+def _convert_function_call_to_genai(fc: FunctionCall | None) -> types.FunctionCall | None:
+    """Convert custom FunctionCall to google.genai.types.FunctionCall"""
+    if fc is None:
+        return None
+    return types.FunctionCall.model_construct(**fc.__dict__)
+
+
+def _convert_function_response_to_genai(fr: FunctionResponse | None) -> types.FunctionResponse | None:
+    """Convert custom FunctionResponse to google.genai.types.FunctionResponse"""
+    if fr is None:
+        return None
+    return types.FunctionResponse.model_construct(**fr.__dict__)
+
+
+def _convert_part_to_genai(part: Part | PartLike) -> types.Part:
+    """Convert custom Part or PartLike to google.genai.types.Part"""
+    # Handle inline_data conversion
+    inline_data = None
+    if part.inline_data is not None:
+        if isinstance(part.inline_data, Blob):
+            inline_data = _convert_blob_to_genai(part.inline_data)
+        else:
+            # It's already a types.Blob or compatible object
+            inline_data = types.Blob.model_construct(**part.inline_data.__dict__)
+    
+    # Handle function_call conversion
+    function_call = None
+    if part.function_call is not None:
+        if isinstance(part.function_call, FunctionCall):
+            function_call = _convert_function_call_to_genai(part.function_call)
+        else:
+            # It's already a compatible type
+            function_call = types.FunctionCall.model_construct(**part.function_call.__dict__)
+    
+    # Handle function_response conversion
+    function_response = None
+    if part.function_response is not None:
+        if isinstance(part.function_response, FunctionResponse):
+            function_response = _convert_function_response_to_genai(part.function_response)
+        else:
+            # It's already a compatible type
+            function_response = types.FunctionResponse.model_construct(**part.function_response.__dict__)
+    
+    return types.Part.model_construct(
+        text=part.text,
+        function_call=function_call,
+        function_response=function_response,
+        thought=part.thought,
+        inline_data=inline_data,
+    )
+
+
+def _convert_content_to_genai(content: Content) -> types.Content:
+    """Convert custom Content to google.genai.types.Content"""
+    genai_parts: list[types.Part] | None = None
+    if content.parts is not None:
+        genai_parts = [_convert_part_to_genai(p) for p in content.parts]
+    return types.Content.model_construct(
+        role=content.role,
+        parts=genai_parts,
+    )
+
+
+def _convert_messages_to_genai(messages: list[Content]) -> list[types.Content]:
+    """Convert list of custom Content to list of google.genai.types.Content"""
+    return [_convert_content_to_genai(msg) for msg in messages]
+
+
+def _convert_thinking_config_to_genai(thinking_config: ThinkingConfig | None) -> types.ThinkingConfig | None:
+    """Convert custom ThinkingConfig to google.genai.types.ThinkingConfig"""
+    if thinking_config is None:
+        return None
+    return types.ThinkingConfig.model_construct(**thinking_config.__dict__)
+
+
+def _convert_schema_to_genai(schema: Schema | None) -> types.Schema | None:
+    """Convert custom Schema to google.genai.types.Schema"""
+    if schema is None:
+        return None
+    return types.Schema.model_construct(
+        example=schema.example,
+        pattern=schema.pattern,
+        minimum=schema.minimum,
+        default=schema.default,
+        any_of=[_convert_schema_to_genai(s) for s in schema.any_of] if schema.any_of else None,
+        max_length=schema.max_length,
+        title=schema.title,
+        min_length=schema.min_length,
+        min_properties=schema.min_properties,
+        maximum=schema.maximum,
+        max_properties=schema.max_properties,
+        description=schema.description,
+        enum=schema.enum,
+        format=schema.format,
+        items=_convert_schema_to_genai(schema.items),
+        max_items=schema.max_items,
+        min_items=schema.min_items,
+        nullable=schema.nullable,
+        properties={k: _convert_schema_to_genai(v) for k, v in schema.properties.items()} if schema.properties else None,
+        property_ordering=schema.property_ordering,
+        required=schema.required,
+        type=schema.type,
+    )
+
+
+def _convert_function_declaration_to_genai(fd: FunctionDeclaration) -> types.FunctionDeclaration:
+    """Convert custom FunctionDeclaration to google.genai.types.FunctionDeclaration"""
+    return types.FunctionDeclaration.model_construct(
+        response=_convert_schema_to_genai(fd.response),
+        description=fd.description,
+        name=fd.name,
+        parameters=_convert_schema_to_genai(fd.parameters),
+    )
+
+
+def _convert_tool_to_genai(tool: Tool) -> types.Tool:
+    """Convert custom Tool to google.genai.types.Tool"""
+    genai_declarations = None
+    if tool.function_declarations is not None:
+        genai_declarations = [_convert_function_declaration_to_genai(fd) for fd in tool.function_declarations]
+    return types.Tool.model_construct(
+        function_declarations=genai_declarations,
+    )
+
+
+def _convert_tools_to_genai(tools: list[Tool] | None) -> list[types.Tool] | None:
+    """Convert list of custom Tool to list of google.genai.types.Tool"""
+    if tools is None:
+        return None
+    return [_convert_tool_to_genai(t) for t in tools]
+
+
+def _convert_function_calling_config_to_genai(fcc: FunctionCallingConfig | None) -> types.FunctionCallingConfig | None:
+    """Convert custom FunctionCallingConfig to google.genai.types.FunctionCallingConfig"""
+    if fcc is None:
+        return None
+    return types.FunctionCallingConfig.model_construct(**fcc.__dict__)
+
+
+def _convert_tool_config_to_genai(tool_config: ToolConfig | None) -> types.ToolConfig | None:
+    """Convert custom ToolConfig to google.genai.types.ToolConfig"""
+    if tool_config is None:
+        return None
+    return types.ToolConfig.model_construct(
+        function_calling_config=_convert_function_calling_config_to_genai(tool_config.function_calling_config),
+    )
+
+
 @inherited_decorator
 def _error_handler(func: Callable[P, Response]) -> Callable[P, Response]:
     """
@@ -100,13 +255,18 @@ class GoogleLLMClient(BaseLLMClient):
         tool_config: ToolConfig = ToolConfig(),
     ) -> Response:
         messages = self._preprocess_messages(messages)
+        # Convert custom types to google.genai.types
+        genai_messages = _convert_messages_to_genai(messages)
+        genai_tools = _convert_tools_to_genai(tools)
+        genai_tool_config = _convert_tool_config_to_genai(tool_config)
+        
         if max_tokens is None:
             max_tokens = self.default_max_tokens
         config = types.GenerateContentConfig(
             system_instruction=system_message,
             max_output_tokens=max_tokens,
-            tools=tools,
-            tool_config=tool_config,
+            tools=genai_tools,
+            tool_config=genai_tool_config,
         )
         if timeout is not None:
             # Google processes timeout via HttpOptions on the request/config
@@ -114,19 +274,19 @@ class GoogleLLMClient(BaseLLMClient):
         
         if thinking_config is None:
             thinking_config = self.default_thinking_config
-        config.thinking_config = thinking_config
+        config.thinking_config = _convert_thinking_config_to_genai(thinking_config)
         
         if result_type is None:
             return self.client.models.generate_content(
                 model=self.model,
-                contents=messages,
+                contents=genai_messages,
                 config=config,
             )
         elif result_type == "json":
             config.response_mime_type = "application/json"
             response = self.client.models.generate_content(
                 model=self.model,
-                contents=messages,
+                contents=genai_messages,
                 config=config,
             )
             response.parsed = BaseLLMClient.as_json(response.text)
@@ -136,7 +296,7 @@ class GoogleLLMClient(BaseLLMClient):
             config.response_schema = result_type
             return self.client.models.generate_content(
                 model=self.model,
-                contents=messages,
+                contents=genai_messages,
                 config=config,
             )
         else:
@@ -151,6 +311,9 @@ class GoogleLLMClient(BaseLLMClient):
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> Iterator[Response]:
+        # Convert custom types to google.genai.types
+        genai_messages = _convert_messages_to_genai(messages)
+        
         if max_tokens is None:
             max_tokens = self.default_max_tokens
         config = types.GenerateContentConfig(
@@ -160,11 +323,11 @@ class GoogleLLMClient(BaseLLMClient):
         
         if thinking_config is None:
             thinking_config = self.default_thinking_config
-        config.thinking_config = thinking_config
+        config.thinking_config = _convert_thinking_config_to_genai(thinking_config)
         
         response = self.client.models.generate_content_stream(
             model=self.model,
-            contents=[msg.model_dump() for msg in  messages],
+            contents=genai_messages,
             config=config,
         )
         return response
@@ -258,32 +421,37 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
         tool_config: ToolConfig = ToolConfig(),
     ) -> Response:
         messages = GoogleLLMClient._preprocess_messages(messages)
+        # Convert custom types to google.genai.types
+        genai_messages = _convert_messages_to_genai(messages)
+        genai_tools = _convert_tools_to_genai(tools)
+        genai_tool_config = _convert_tool_config_to_genai(tool_config)
+        
         if max_tokens is None:
             max_tokens = self.default_max_tokens
         config = types.GenerateContentConfig(
             system_instruction=system_message,
             max_output_tokens=max_tokens,
-            tools=tools,
-            tool_config=tool_config,
+            tools=genai_tools,
+            tool_config=genai_tool_config,
         )
         if timeout is not None:
             config.http_options = types.HttpOptions(timeout=int(timeout * 1_000))
 
         if thinking_config is None:
             thinking_config = self.default_thinking_config
-        config.thinking_config = thinking_config
+        config.thinking_config = _convert_thinking_config_to_genai(thinking_config)
 
         if result_type is None:
             return await self.client.aio.models.generate_content(
                 model=self.model,
-                contents=messages,
+                contents=genai_messages,
                 config=config,
             )
         elif result_type == "json":
             config.response_mime_type = "application/json"
             return await self.client.aio.models.generate_content(
                 model=self.model,
-                contents=messages,
+                contents=genai_messages,
                 config=config,
             )
         elif isinstance(result_type, type(BaseModel)):
@@ -291,7 +459,7 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
             config.response_schema = result_type
             return await self.client.aio.models.generate_content(
                 model=self.model,
-                contents=messages,
+                contents=genai_messages,
                 config=config,
             )
         else:
@@ -306,6 +474,9 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> AsyncIterator[Response]:
+        # Convert custom types to google.genai.types
+        genai_messages = _convert_messages_to_genai(messages)
+        
         if max_tokens is None:
             max_tokens = self.default_max_tokens
         config = types.GenerateContentConfig(
@@ -315,11 +486,11 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
         
         if thinking_config is None:
             thinking_config = self.default_thinking_config
-        config.thinking_config = thinking_config
+        config.thinking_config = _convert_thinking_config_to_genai(thinking_config)
         
         response = await self.client.aio.models.generate_content_stream(
             model=self.model,
-            contents=[msg.model_dump() for msg in  messages],
+            contents=genai_messages,
             config=config,
         )
         return response

{promptbuilder-0.4.40 → promptbuilder-0.4.42/promptbuilder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: promptbuilder
-Version: 0.4.40
+Version: 0.4.42
 Summary: Library for building prompts for LLMs
 Home-page: https://github.com/kapulkin/promptbuilder
 Author: Kapulkin Stanislav

{promptbuilder-0.4.40 → promptbuilder-0.4.42}/promptbuilder.egg-info/SOURCES.txt

@@ -30,8 +30,10 @@ promptbuilder/llm_client/main.py
 promptbuilder/llm_client/openai_client.py
 promptbuilder/llm_client/types.py
 promptbuilder/llm_client/utils.py
+tests/test_google_conversions.py
 tests/test_llm_client.py
 tests/test_llm_client_async.py
+tests/test_models_list.py
 tests/test_timeout_google.py
 tests/test_timeout_litellm.py
 tests/test_timeout_openai.py

{promptbuilder-0.4.40 → promptbuilder-0.4.42}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="promptbuilder",
-    version="0.4.40",
+    version="0.4.42",
     packages=find_packages(),
     install_requires=[
         "pydantic",

promptbuilder-0.4.42/tests/test_google_conversions.py

@@ -0,0 +1,426 @@
+"""
+Tests for conversion functions in google_client.py
+Verifies that custom types' __dict__ contains exactly the fields needed for google.genai.types
+"""
+import pytest
+from google.genai import types as genai_types
+
+from promptbuilder.llm_client.types import (
+    Blob,
+    FunctionCall,
+    FunctionResponse,
+    Part,
+    Content,
+    ThinkingConfig,
+    Schema,
+    FunctionDeclaration,
+    Tool,
+    FunctionCallingConfig,
+    ToolConfig,
+)
+from promptbuilder.llm_client.google_client import (
+    _convert_blob_to_genai,
+    _convert_function_call_to_genai,
+    _convert_function_response_to_genai,
+    _convert_part_to_genai,
+    _convert_content_to_genai,
+    _convert_thinking_config_to_genai,
+    _convert_schema_to_genai,
+    _convert_function_declaration_to_genai,
+    _convert_tool_to_genai,
+    _convert_function_calling_config_to_genai,
+    _convert_tool_config_to_genai,
+    _convert_messages_to_genai,
+    _convert_tools_to_genai,
+)
+
+
+def get_pydantic_fields(cls) -> set[str]:
+    """Get field names from a Pydantic model class using the non-deprecated approach."""
+    return set(cls.__pydantic_fields__.keys())
+
+
+class TestFieldCompatibility:
+    """Test that custom types have compatible fields with google.genai.types"""
+    
+    def test_blob_fields_match(self):
+        """Blob __dict__ should have fields compatible with genai_types.Blob"""
+        custom_fields = get_pydantic_fields(Blob)
+        genai_fields = get_pydantic_fields(genai_types.Blob)
+        
+        # Our custom type may have extra fields (like display_name) that genai doesn't have
+        # But all genai fields should be in our custom type or we handle them
+        blob = Blob(data=b"test", mime_type="text/plain", display_name="test.txt")
+        
+        # Check that conversion works
+        result = _convert_blob_to_genai(blob)
+        assert isinstance(result, genai_types.Blob)
+        assert result.data == b"test"
+        assert result.mime_type == "text/plain"
+    
+    def test_function_call_fields_match(self):
+        """FunctionCall __dict__ should have fields compatible with genai_types.FunctionCall"""
+        custom_fields = get_pydantic_fields(FunctionCall)
+        genai_fields = get_pydantic_fields(genai_types.FunctionCall)
+        
+        fc = FunctionCall(id="123", args={"key": "value"}, name="test_func")
+        
+        result = _convert_function_call_to_genai(fc)
+        assert isinstance(result, genai_types.FunctionCall)
+        assert result.id == "123"
+        assert result.args == {"key": "value"}
+        assert result.name == "test_func"
+    
+    def test_function_response_fields_match(self):
+        """FunctionResponse __dict__ should have fields compatible with genai_types.FunctionResponse"""
+        fr = FunctionResponse(id="456", name="test_func", response={"result": 42})
+        
+        result = _convert_function_response_to_genai(fr)
+        assert isinstance(result, genai_types.FunctionResponse)
+        assert result.id == "456"
+        assert result.name == "test_func"
+        assert result.response == {"result": 42}
+    
+    def test_thinking_config_fields_match(self):
+        """ThinkingConfig __dict__ should have fields compatible with genai_types.ThinkingConfig"""
+        tc = ThinkingConfig(include_thoughts=True, thinking_budget=1000)
+        
+        result = _convert_thinking_config_to_genai(tc)
+        assert isinstance(result, genai_types.ThinkingConfig)
+        assert result.include_thoughts == True
+        assert result.thinking_budget == 1000
+    
+    def test_function_calling_config_fields_match(self):
+        """FunctionCallingConfig __dict__ should have fields compatible with genai_types.FunctionCallingConfig"""
+        fcc = FunctionCallingConfig(mode="AUTO", allowed_function_names=["func1", "func2"])
+        
+        result = _convert_function_calling_config_to_genai(fcc)
+        assert isinstance(result, genai_types.FunctionCallingConfig)
+        assert result.mode == "AUTO"
+        assert result.allowed_function_names == ["func1", "func2"]
+
+
+class TestConversionFunctions:
+    """Test that conversion functions produce correct results"""
+    
+    def test_convert_blob_none(self):
+        assert _convert_blob_to_genai(None) is None
+    
+    def test_convert_blob_with_data(self):
+        blob = Blob(data=b"hello", mime_type="text/plain")
+        result = _convert_blob_to_genai(blob)
+        assert isinstance(result, genai_types.Blob)
+        assert result.data == b"hello"
+        assert result.mime_type == "text/plain"
+    
+    def test_convert_function_call_none(self):
+        assert _convert_function_call_to_genai(None) is None
+    
+    def test_convert_function_call_with_data(self):
+        fc = FunctionCall(id="test-id", name="my_function", args={"x": 1})
+        result = _convert_function_call_to_genai(fc)
+        assert isinstance(result, genai_types.FunctionCall)
+        assert result.id == "test-id"
+        assert result.name == "my_function"
+        assert result.args == {"x": 1}
+    
+    def test_convert_function_response_none(self):
+        assert _convert_function_response_to_genai(None) is None
+    
+    def test_convert_function_response_with_data(self):
+        fr = FunctionResponse(id="resp-id", name="my_function", response={"output": "success"})
+        result = _convert_function_response_to_genai(fr)
+        assert isinstance(result, genai_types.FunctionResponse)
+        assert result.id == "resp-id"
+        assert result.name == "my_function"
+        assert result.response == {"output": "success"}
+    
+    def test_convert_part_text_only(self):
+        part = Part(text="Hello world")
+        result = _convert_part_to_genai(part)
+        assert isinstance(result, genai_types.Part)
+        assert result.text == "Hello world"
+        assert result.function_call is None
+        assert result.function_response is None
+        assert result.inline_data is None
+    
+    def test_convert_part_with_function_call(self):
+        fc = FunctionCall(id="fc-1", name="calc", args={"a": 1, "b": 2})
+        part = Part(function_call=fc)
+        result = _convert_part_to_genai(part)
+        assert isinstance(result, genai_types.Part)
+        assert result.function_call is not None
+        assert isinstance(result.function_call, genai_types.FunctionCall)
+        assert result.function_call.name == "calc"
+    
+    def test_convert_part_with_inline_data(self):
+        blob = Blob(data=b"image data", mime_type="image/png")
+        part = Part(inline_data=blob)
+        result = _convert_part_to_genai(part)
+        assert isinstance(result, genai_types.Part)
+        assert result.inline_data is not None
+        assert isinstance(result.inline_data, genai_types.Blob)
+        assert result.inline_data.mime_type == "image/png"
+    
+    def test_convert_part_with_thought(self):
+        part = Part(text="thinking...", thought=True)
+        result = _convert_part_to_genai(part)
+        assert isinstance(result, genai_types.Part)
+        assert result.text == "thinking..."
+        assert result.thought == True
+    
+    def test_convert_content_simple(self):
+        content = Content(role="user", parts=[Part(text="Hello")])
+        result = _convert_content_to_genai(content)
+        assert isinstance(result, genai_types.Content)
+        assert result.role == "user"
+        assert len(result.parts) == 1
+        assert isinstance(result.parts[0], genai_types.Part)
+        assert result.parts[0].text == "Hello"
+    
+    def test_convert_content_multiple_parts(self):
+        content = Content(
+            role="model",
+            parts=[
+                Part(text="Part 1"),
+                Part(text="Part 2"),
+            ]
+        )
+        result = _convert_content_to_genai(content)
+        assert isinstance(result, genai_types.Content)
+        assert result.role == "model"
+        assert len(result.parts) == 2
+    
+    def test_convert_content_no_parts(self):
+        content = Content(role="user", parts=None)
+        result = _convert_content_to_genai(content)
+        assert isinstance(result, genai_types.Content)
+        assert result.parts is None
+    
+    def test_convert_messages(self):
+        messages = [
+            Content(role="user", parts=[Part(text="Hi")]),
+            Content(role="model", parts=[Part(text="Hello!")]),
+        ]
+        result = _convert_messages_to_genai(messages)
+        assert len(result) == 2
+        assert all(isinstance(m, genai_types.Content) for m in result)
+    
+    def test_convert_thinking_config_none(self):
+        assert _convert_thinking_config_to_genai(None) is None
+    
+    def test_convert_thinking_config_with_data(self):
+        tc = ThinkingConfig(include_thoughts=True, thinking_budget=500)
+        result = _convert_thinking_config_to_genai(tc)
+        assert isinstance(result, genai_types.ThinkingConfig)
+        assert result.include_thoughts == True
+        assert result.thinking_budget == 500
+    
+    def test_convert_schema_none(self):
+        assert _convert_schema_to_genai(None) is None
+    
+    def test_convert_schema_simple(self):
+        schema = Schema(type="string", description="A name")
+        result = _convert_schema_to_genai(schema)
+        assert isinstance(result, genai_types.Schema)
+        assert result.type == "string"
+        assert result.description == "A name"
+    
+    def test_convert_schema_with_properties(self):
+        schema = Schema(
+            type="object",
+            properties={
+                "name": Schema(type="string"),
+                "age": Schema(type="integer"),
+            },
+            required=["name"]
+        )
+        result = _convert_schema_to_genai(schema)
+        assert isinstance(result, genai_types.Schema)
+        assert result.type == "object"
+        assert "name" in result.properties
+        assert "age" in result.properties
+        assert isinstance(result.properties["name"], genai_types.Schema)
+        assert result.required == ["name"]
+    
+    def test_convert_schema_with_items(self):
+        schema = Schema(
+            type="array",
+            items=Schema(type="string")
+        )
+        result = _convert_schema_to_genai(schema)
+        assert isinstance(result, genai_types.Schema)
+        assert result.type == "array"
+        assert isinstance(result.items, genai_types.Schema)
+        assert result.items.type == "string"
+    
+    def test_convert_function_declaration(self):
+        fd = FunctionDeclaration(
+            name="get_weather",
+            description="Get weather for a location",
+            parameters=Schema(
+                type="object",
+                properties={
+                    "location": Schema(type="string", description="City name"),
+                },
+                required=["location"]
+            )
+        )
+        result = _convert_function_declaration_to_genai(fd)
+        assert isinstance(result, genai_types.FunctionDeclaration)
+        assert result.name == "get_weather"
+        assert result.description == "Get weather for a location"
+        assert isinstance(result.parameters, genai_types.Schema)
+    
+    def test_convert_tool(self):
+        tool = Tool(
+            function_declarations=[
+                FunctionDeclaration(name="func1", description="First function"),
+                FunctionDeclaration(name="func2", description="Second function"),
+            ]
+        )
+        result = _convert_tool_to_genai(tool)
+        assert isinstance(result, genai_types.Tool)
+        assert len(result.function_declarations) == 2
+        assert all(isinstance(fd, genai_types.FunctionDeclaration) for fd in result.function_declarations)
+    
+    def test_convert_tool_no_declarations(self):
+        tool = Tool(function_declarations=None)
+        result = _convert_tool_to_genai(tool)
+        assert isinstance(result, genai_types.Tool)
+        assert result.function_declarations is None
+    
+    def test_convert_tools_none(self):
+        assert _convert_tools_to_genai(None) is None
+    
+    def test_convert_tools_list(self):
+        tools = [
+            Tool(function_declarations=[FunctionDeclaration(name="f1")]),
+            Tool(function_declarations=[FunctionDeclaration(name="f2")]),
+        ]
+        result = _convert_tools_to_genai(tools)
+        assert len(result) == 2
+        assert all(isinstance(t, genai_types.Tool) for t in result)
+    
+    def test_convert_function_calling_config_none(self):
+        assert _convert_function_calling_config_to_genai(None) is None
+    
+    def test_convert_function_calling_config_with_data(self):
+        fcc = FunctionCallingConfig(mode="ANY", allowed_function_names=["allowed_func"])
+        result = _convert_function_calling_config_to_genai(fcc)
+        assert isinstance(result, genai_types.FunctionCallingConfig)
+        assert result.mode == "ANY"
+        assert result.allowed_function_names == ["allowed_func"]
+    
+    def test_convert_tool_config_none(self):
+        assert _convert_tool_config_to_genai(None) is None
+    
+    def test_convert_tool_config_with_data(self):
+        tc = ToolConfig(
+            function_calling_config=FunctionCallingConfig(mode="NONE")
+        )
+        result = _convert_tool_config_to_genai(tc)
+        assert isinstance(result, genai_types.ToolConfig)
+        assert isinstance(result.function_calling_config, genai_types.FunctionCallingConfig)
+        assert result.function_calling_config.mode == "NONE"
+
+
+class TestDictFieldsExactMatch:
+    """
+    Test that __dict__ of custom types contains exactly the fields needed
+    for model_construct to work with google.genai.types
+    """
+    
+    def test_blob_dict_fields(self):
+        """Verify Blob.__dict__ contains only expected fields"""
+        blob = Blob(data=b"test", mime_type="text/plain", display_name="file.txt")
+        dict_keys = set(blob.__dict__.keys())
+        expected_keys = {"data", "mime_type", "display_name"}
+        assert dict_keys == expected_keys
+    
+    def test_function_call_dict_fields(self):
+        """Verify FunctionCall.__dict__ contains only expected fields"""
+        fc = FunctionCall(id="1", args={"a": 1}, name="test")
+        dict_keys = set(fc.__dict__.keys())
+        expected_keys = {"id", "args", "name"}
+        assert dict_keys == expected_keys
+    
+    def test_function_response_dict_fields(self):
+        """Verify FunctionResponse.__dict__ contains only expected fields"""
+        fr = FunctionResponse(id="1", name="test", response={"x": 1})
+        dict_keys = set(fr.__dict__.keys())
+        expected_keys = {"id", "name", "response"}
+        assert dict_keys == expected_keys
+    
+    def test_thinking_config_dict_fields(self):
+        """Verify ThinkingConfig.__dict__ contains only expected fields"""
+        tc = ThinkingConfig(include_thoughts=True, thinking_budget=100)
+        dict_keys = set(tc.__dict__.keys())
+        expected_keys = {"include_thoughts", "thinking_budget"}
+        assert dict_keys == expected_keys
+    
+    def test_function_calling_config_dict_fields(self):
+        """Verify FunctionCallingConfig.__dict__ contains only expected fields"""
+        fcc = FunctionCallingConfig(mode="AUTO", allowed_function_names=["f"])
+        dict_keys = set(fcc.__dict__.keys())
+        expected_keys = {"mode", "allowed_function_names"}
+        assert dict_keys == expected_keys
+    
+    def test_part_dict_fields(self):
+        """Verify Part.__dict__ contains only expected fields"""
+        part = Part(text="hello", thought=True, function_call=None, function_response=None, inline_data=None)
+        dict_keys = set(part.__dict__.keys())
+        expected_keys = {"text", "function_call", "function_response", "thought", "inline_data"}
+        assert dict_keys == expected_keys
+    
+    def test_content_dict_fields(self):
+        """Verify Content.__dict__ contains only expected fields"""
+        content = Content(role="user", parts=[Part(text="hi")])
+        dict_keys = set(content.__dict__.keys())
+        expected_keys = {"role", "parts"}
+        assert dict_keys == expected_keys
+
+
+class TestModelConstructCompatibility:
+    """
+    Test that model_construct(**obj.__dict__) works correctly
+    by verifying genai types accept our custom type's __dict__
+    """
+    
+    def test_blob_model_construct_works(self):
+        """genai_types.Blob.model_construct should work with Blob.__dict__"""
+        blob = Blob(data=b"test", mime_type="text/plain")
+        # This should not raise
+        result = genai_types.Blob.model_construct(**blob.__dict__)
+        assert result.data == b"test"
+        assert result.mime_type == "text/plain"
+    
+    def test_function_call_model_construct_works(self):
+        """genai_types.FunctionCall.model_construct should work with FunctionCall.__dict__"""
+        fc = FunctionCall(id="test", args={"x": 1}, name="func")
+        result = genai_types.FunctionCall.model_construct(**fc.__dict__)
+        assert result.id == "test"
+        assert result.args == {"x": 1}
+        assert result.name == "func"
+    
+    def test_function_response_model_construct_works(self):
+        """genai_types.FunctionResponse.model_construct should work with FunctionResponse.__dict__"""
+        fr = FunctionResponse(id="resp", name="func", response={"out": 42})
+        result = genai_types.FunctionResponse.model_construct(**fr.__dict__)
+        assert result.id == "resp"
+        assert result.name == "func"
+        assert result.response == {"out": 42}
+    
+    def test_thinking_config_model_construct_works(self):
+        """genai_types.ThinkingConfig.model_construct should work with ThinkingConfig.__dict__"""
+        tc = ThinkingConfig(include_thoughts=True, thinking_budget=200)
+        result = genai_types.ThinkingConfig.model_construct(**tc.__dict__)
+        assert result.include_thoughts == True
+        assert result.thinking_budget == 200
+    
+    def test_function_calling_config_model_construct_works(self):
+        """genai_types.FunctionCallingConfig.model_construct should work with FunctionCallingConfig.__dict__"""
+        fcc = FunctionCallingConfig(mode="AUTO", allowed_function_names=["f1", "f2"])
+        result = genai_types.FunctionCallingConfig.model_construct(**fcc.__dict__)
+        assert result.mode == "AUTO"
+        assert result.allowed_function_names == ["f1", "f2"]

promptbuilder-0.4.42/tests/test_models_list.py

@@ -0,0 +1,185 @@
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from promptbuilder.llm_client.main import get_models_list
+from promptbuilder.llm_client.types import Model
+
+
+def test_get_models_list_all_providers():
+    """Test that get_models_list returns models from all providers when no provider specified."""
+    with patch('promptbuilder.llm_client.google_client.GoogleLLMClient.models_list') as mock_google, \
+         patch('promptbuilder.llm_client.anthropic_client.AnthropicLLMClient.models_list') as mock_anthropic, \
+         patch('promptbuilder.llm_client.openai_client.OpenaiLLMClient.models_list') as mock_openai, \
+         patch('promptbuilder.llm_client.bedrock_client.BedrockLLMClient.models_list') as mock_bedrock:
+        
+        # Setup mock returns
+        mock_google.return_value = [
+            Model(full_model_name="google:gemini-1.5-flash", provider="google", model="gemini-1.5-flash", display_name="Gemini 1.5 Flash")
+        ]
+        mock_anthropic.return_value = [
+            Model(full_model_name="anthropic:claude-3-opus-20240229", provider="anthropic", model="claude-3-opus-20240229", display_name="Claude 3 Opus")
+        ]
+        mock_openai.return_value = [
+            Model(full_model_name="openai:gpt-4", provider="openai", model="gpt-4")
+        ]
+        mock_bedrock.return_value = [
+            Model(full_model_name="bedrock:arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-sonnet-20240229-v1:0", 
+                  provider="bedrock", 
+                  model="arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-sonnet-20240229-v1:0",
+                  display_name="Claude 3 Sonnet")
+        ]
+        
+        # Call the function
+        result = get_models_list()
+        
+        # Assertions
+        assert len(result) == 4
+        assert all(isinstance(model, Model) for model in result)
+        assert any(model.provider == "google" for model in result)
+        assert any(model.provider == "anthropic" for model in result)
+        assert any(model.provider == "openai" for model in result)
+        assert any(model.provider == "bedrock" for model in result)
+        
+        # Verify all mocks were called
+        mock_google.assert_called_once()
+        mock_anthropic.assert_called_once()
+        mock_openai.assert_called_once()
+        mock_bedrock.assert_called_once()
+
+
+def test_get_models_list_google_provider():
+    """Test that get_models_list returns only Google models when google provider specified."""
+    with patch('promptbuilder.llm_client.google_client.GoogleLLMClient.models_list') as mock_google:
+        mock_google.return_value = [
+            Model(full_model_name="google:gemini-1.5-flash", provider="google", model="gemini-1.5-flash", display_name="Gemini 1.5 Flash"),
+            Model(full_model_name="google:gemini-1.5-pro", provider="google", model="gemini-1.5-pro", display_name="Gemini 1.5 Pro")
+        ]
+        
+        result = get_models_list(provider="google")
+        
+        assert len(result) == 2
+        assert all(model.provider == "google" for model in result)
+        mock_google.assert_called_once()
+
+
+def test_get_models_list_anthropic_provider():
+    """Test that get_models_list returns only Anthropic models when anthropic provider specified."""
+    with patch('promptbuilder.llm_client.anthropic_client.AnthropicLLMClient.models_list') as mock_anthropic:
+        mock_anthropic.return_value = [
+            Model(full_model_name="anthropic:claude-3-opus-20240229", provider="anthropic", model="claude-3-opus-20240229", display_name="Claude 3 Opus"),
+            Model(full_model_name="anthropic:claude-3-sonnet-20240229", provider="anthropic", model="claude-3-sonnet-20240229", display_name="Claude 3 Sonnet")
+        ]
+        
+        result = get_models_list(provider="anthropic")
+        
+        assert len(result) == 2
+        assert all(model.provider == "anthropic" for model in result)
+        mock_anthropic.assert_called_once()
+
+
+def test_get_models_list_openai_provider():
+    """Test that get_models_list returns only OpenAI models when openai provider specified."""
+    with patch('promptbuilder.llm_client.openai_client.OpenaiLLMClient.models_list') as mock_openai:
+        mock_openai.return_value = [
+            Model(full_model_name="openai:gpt-4", provider="openai", model="gpt-4"),
+            Model(full_model_name="openai:gpt-3.5-turbo", provider="openai", model="gpt-3.5-turbo")
+        ]
+        
+        result = get_models_list(provider="openai")
+        
+        assert len(result) == 2
+        assert all(model.provider == "openai" for model in result)
+        mock_openai.assert_called_once()
+
+
+def test_get_models_list_bedrock_provider():
+    """Test that get_models_list returns only Bedrock models when bedrock provider specified."""
+    with patch('promptbuilder.llm_client.bedrock_client.BedrockLLMClient.models_list') as mock_bedrock:
+        mock_bedrock.return_value = [
+            Model(full_model_name="bedrock:arn1", provider="bedrock", model="arn1", display_name="Model 1"),
+            Model(full_model_name="bedrock:arn2", provider="bedrock", model="arn2", display_name="Model 2")
+        ]
+        
+        result = get_models_list(provider="bedrock")
+        
+        assert len(result) == 2
+        assert all(model.provider == "bedrock" for model in result)
+        mock_bedrock.assert_called_once()
+
+
+def test_get_models_list_invalid_provider():
+    """Test that get_models_list returns empty list for invalid provider."""
+    result = get_models_list(provider="invalid_provider")
+    
+    assert result == []
+    assert isinstance(result, list)
+
+
+def test_get_models_list_empty_responses():
+    """Test that get_models_list handles empty responses from providers."""
+    with patch('promptbuilder.llm_client.google_client.GoogleLLMClient.models_list') as mock_google, \
+         patch('promptbuilder.llm_client.anthropic_client.AnthropicLLMClient.models_list') as mock_anthropic, \
+         patch('promptbuilder.llm_client.openai_client.OpenaiLLMClient.models_list') as mock_openai, \
+         patch('promptbuilder.llm_client.bedrock_client.BedrockLLMClient.models_list') as mock_bedrock:
+        
+        # All providers return empty lists
+        mock_google.return_value = []
+        mock_anthropic.return_value = []
+        mock_openai.return_value = []
+        mock_bedrock.return_value = []
+        
+        result = get_models_list()
+        
+        assert result == []
+        assert isinstance(result, list)
+
+
+def test_model_structure():
+    """Test that Model objects have the expected structure."""
+    with patch('promptbuilder.llm_client.google_client.GoogleLLMClient.models_list') as mock_google:
+        mock_google.return_value = [
+            Model(
+                full_model_name="google:gemini-1.5-flash", 
+                provider="google", 
+                model="gemini-1.5-flash", 
+                display_name="Gemini 1.5 Flash"
+            )
+        ]
+        
+        result = get_models_list(provider="google")
+        
+        assert len(result) == 1
+        model = result[0]
+        
+        # Check all fields exist
+        assert hasattr(model, 'full_model_name')
+        assert hasattr(model, 'provider')
+        assert hasattr(model, 'model')
+        assert hasattr(model, 'display_name')
+        
+        # Check field values
+        assert model.full_model_name == "google:gemini-1.5-flash"
+        assert model.provider == "google"
+        assert model.model == "gemini-1.5-flash"
+        assert model.display_name == "Gemini 1.5 Flash"
+
+
+def test_model_without_display_name():
+    """Test that Model objects can be created without display_name (optional field)."""
+    with patch('promptbuilder.llm_client.openai_client.OpenaiLLMClient.models_list') as mock_openai:
+        mock_openai.return_value = [
+            Model(
+                full_model_name="openai:gpt-4", 
+                provider="openai", 
+                model="gpt-4"
+            )
+        ]
+        
+        result = get_models_list(provider="openai")
+        
+        assert len(result) == 1
+        model = result[0]
+        
+        assert model.full_model_name == "openai:gpt-4"
+        assert model.provider == "openai"
+        assert model.model == "gpt-4"
+        assert model.display_name is None