promptbuilder 0.4.40__py3-none-any.whl → 0.4.42__py3-none-any.whl

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/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.dist-info → promptbuilder-0.4.42.dist-info}/METADATA

@@ -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.dist-info → promptbuilder-0.4.42.dist-info}/RECORD

@@ -9,19 +9,19 @@ promptbuilder/agent/utils.py,sha256=vTkphKw04v_QDIJtoB2JKK0RGY6iI1t_0LbmuStunzI,
 promptbuilder/llm_client/__init__.py,sha256=wJ33cnRtZX_YPsbcGxEu3SEZMOhPX7-fHI59MEPUe7I,517
 promptbuilder/llm_client/aisuite_client.py,sha256=8inY3UoH8o9yEOvRYP6a_8pjGQK0W_f9eV8MmHzpKTU,15641
 promptbuilder/llm_client/anthropic_client.py,sha256=YR1Pc4Fj0WpG7qcQnPLkQMzDsvA7SMvWomFR1oCzMsk,28328
-promptbuilder/llm_client/base_client.py,sha256=2aXxOwhQGx7-fqaW-QDeRjtO5-egGqdyVOuOttGaplI,39750
+promptbuilder/llm_client/base_client.py,sha256=tpYnXFxohqoMTTmYUBZrWjRgX__TnD48vym9VHNJplo,40513
 promptbuilder/llm_client/bedrock_client.py,sha256=IQt7Sv_Wt6mg5-bhuyr-Nwjx5Nxk2S8rKEVkfwvWqE0,28183
 promptbuilder/llm_client/config.py,sha256=exQEm35wp7lK5SfXNpN5H9VZEb2LVa4pyZ-cxGt1U-U,1124
 promptbuilder/llm_client/exceptions.py,sha256=t-X7r_a8B1jNu8eEavde1jXu5dz97yV3IG4YHOtgh0Y,4836
-promptbuilder/llm_client/google_client.py,sha256=3aaJVCXXlmZ0pDmMERA3QGDklSxkbNmC6e4lIYwJBMg,12551
+promptbuilder/llm_client/google_client.py,sha256=u7VhtufVvJAZqTbJ4TQYq798CSabCJMfK7VU2HQDM6I,19926
 promptbuilder/llm_client/litellm_client.py,sha256=czQd1DM1mEj_yM5BQz9oIPtoJG_B2WpQXsqkKDmLyXE,36398
 promptbuilder/llm_client/logfire_decorators.py,sha256=7FvOcMwP87rv4CVySujA_mTZpZyIa7tdA81_OWJqQKQ,9314
 promptbuilder/llm_client/main.py,sha256=2Q7J5FwivX2YwvptzoSEtCfvfcI9p5HC55D3mMb2se4,8243
 promptbuilder/llm_client/openai_client.py,sha256=ulZZsHhyRbqG1WRdVJcNHk6r6MFBC5XLGJQ_2648AkA,28206
 promptbuilder/llm_client/types.py,sha256=fnkSMFjK9ViaRQsD6LILpLz8R2_E1TI9efjy8VNO0RQ,8139
 promptbuilder/llm_client/utils.py,sha256=EtJFghpn27eVUXR-rZj8inEk903tk3thM0r19QxWnBM,13496
-promptbuilder-0.4.40.dist-info/licenses/LICENSE,sha256=fqXmInzgsvEOIaKSBgcrwKyYCGYF0MKErJ0YivtODcc,1096
-promptbuilder-0.4.40.dist-info/METADATA,sha256=J984D1Sc2jEwOWi1fHT5bnMc283QNmkzrmZWh5Mzwhs,3824
-promptbuilder-0.4.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-promptbuilder-0.4.40.dist-info/top_level.txt,sha256=UBVcYn4UgrPy3O3fmmnPEU_kieuplBMgheetIMei4EI,14
-promptbuilder-0.4.40.dist-info/RECORD,,
+promptbuilder-0.4.42.dist-info/licenses/LICENSE,sha256=fqXmInzgsvEOIaKSBgcrwKyYCGYF0MKErJ0YivtODcc,1096
+promptbuilder-0.4.42.dist-info/METADATA,sha256=fbd1jsCO9oDZ5Rgh37ITWY5u7wcq48d38yTT4ZFH0O8,3824
+promptbuilder-0.4.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+promptbuilder-0.4.42.dist-info/top_level.txt,sha256=UBVcYn4UgrPy3O3fmmnPEU_kieuplBMgheetIMei4EI,14
+promptbuilder-0.4.42.dist-info/RECORD,,