promptbuilder 0.4.16__py3-none-any.whl → 0.4.18__py3-none-any.whl

promptbuilder/llm_client/aisuite_client.py

@@ -115,7 +115,7 @@ class AiSuiteLLMClient(BaseLLMClient):
                         })
             aisuite_kwargs["tools"] = aisuite_tools
         
-        if result_type is None or result_type == "text":
+        if result_type is None or result_type == "json":
             response = self.client.chat.completions.create(**aisuite_kwargs)
             
             parts: list[Part] = []
@@ -164,6 +164,8 @@ class AiSuiteLLMClient(BaseLLMClient):
                 usage_metadata = AiSuiteLLMClient.make_usage_metadata(response.usage) if hasattr(response, "usage") and response.usage is not None else None,
                 parsed=parsed_pydantic,
             )
+        else:
+            raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
 
 
 class AiSuiteLLMClientAsync(BaseLLMClientAsync):
@@ -272,7 +274,7 @@ class AiSuiteLLMClientAsync(BaseLLMClientAsync):
                         })
             aisuite_kwargs["tools"] = aisuite_tools
         
-        if result_type is None or result_type == "text":
+        if result_type is None or result_type == "json":
             response = await self.client.chat.completions.create(**aisuite_kwargs)
             
             parts: list[Part] = []
@@ -321,3 +323,5 @@ class AiSuiteLLMClientAsync(BaseLLMClientAsync):
                 usage_metadata = AiSuiteLLMClient.make_usage_metadata(response.usage) if hasattr(response, "usage") and response.usage is not None else None,
                 parsed=parsed_pydantic,
             )
+        else:
+            raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")

promptbuilder/llm_client/anthropic_client.py

@@ -111,13 +111,14 @@ class AnthropicLLMClient(BaseLLMClient):
         model: str,
         api_key: str = os.getenv("ANTHROPIC_API_KEY"),
         decorator_configs: DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         default_max_tokens_strategy: DefaultMaxTokensStrategy = AnthropicDefaultMaxTokensStrategy(),
         **kwargs,
     ):
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create an anthropic llm client you need to either set the environment variable ANTHROPIC_API_KEY or pass the api_key in string format")
-        super().__init__(AnthropicLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+        super().__init__(AnthropicLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
         self._api_key = api_key
         self.client = Anthropic(api_key=api_key)
         self.default_max_tokens_strategy = default_max_tokens_strategy
@@ -166,7 +167,7 @@ class AnthropicLLMClient(BaseLLMClient):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -185,15 +186,18 @@ class AnthropicLLMClient(BaseLLMClient):
             "messages": anthropic_messages,
         }
         
-        if thinking_config.include_thoughts:
-            anthropic_kwargs["thinking"] = {
-                "budget_tokens": thinking_config.thinking_budget,
-                "type": "enabled",
-            }
-        else:
-            anthropic_kwargs["thinking"] = {
-                "type": "disabled",
-            }
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        if thinking_config is not None:
+            if thinking_config.include_thoughts:
+                anthropic_kwargs["thinking"] = {
+                    "budget_tokens": thinking_config.thinking_budget,
+                    "type": "enabled",
+                }
+            else:
+                anthropic_kwargs["thinking"] = {
+                    "type": "disabled",
+                }
         
         if system_message is not None:
             anthropic_kwargs["system"] = system_message
@@ -224,7 +228,7 @@ class AnthropicLLMClient(BaseLLMClient):
                     tool_choice_mode = tool_config.function_calling_config.mode
             anthropic_kwargs["tool_choice"] = {"type": tool_choice_mode.lower()}
         
-        if result_type is None or result_type == "text":
+        if result_type is None or result_type == "json":
             response = self.client.messages.create(**anthropic_kwargs)
             
             parts: list[Part] = []
@@ -278,6 +282,7 @@ class AnthropicLLMClient(BaseLLMClient):
         self,
         messages: list[Content],
         *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> Iterator[Response]:
@@ -296,6 +301,19 @@ class AnthropicLLMClient(BaseLLMClient):
             "stream": True,
         }
         
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        if thinking_config is not None:
+            if thinking_config.include_thoughts:
+                anthropic_kwargs["thinking"] = {
+                    "budget_tokens": thinking_config.thinking_budget,
+                    "type": "enabled",
+                }
+            else:
+                anthropic_kwargs["thinking"] = {
+                    "type": "disabled",
+                }
+        
         if system_message is not None:
             anthropic_kwargs["system"] = system_message
         
@@ -315,6 +333,7 @@ class AnthropicLLMClient(BaseLLMClient):
             ))
         return models
 
+
 class AnthropicStreamIteratorAsync:
     def __init__(self, anthropic_iterator: AsyncStream[RawMessageStreamEvent]):
         self._anthropic_iterator = anthropic_iterator
@@ -356,13 +375,14 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
         model: str,
         api_key: str = os.getenv("ANTHROPIC_API_KEY"),
         decorator_configs: DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         default_max_tokens_strategy: DefaultMaxTokensStrategy = AnthropicDefaultMaxTokensStrategy(),
         **kwargs,
     ):
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create an anthropic llm client you need to either set the environment variable ANTHROPIC_API_KEY or pass the api_key in string format")
-        super().__init__(AnthropicLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+        super().__init__(AnthropicLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
         self._api_key = api_key
         self.client = AsyncAnthropic(api_key=api_key)
         self.default_max_tokens_strategy = default_max_tokens_strategy
@@ -376,7 +396,7 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -401,15 +421,18 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
             "messages": anthropic_messages,
         }
         
-        if thinking_config.include_thoughts:
-            anthropic_kwargs["thinking"] = {
-                "budget_tokens": thinking_config.thinking_budget,
-                "type": "enabled",
-            }
-        else:
-            anthropic_kwargs["thinking"] = {
-                "type": "disabled",
-            }
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        if thinking_config is not None:
+            if thinking_config.include_thoughts:
+                anthropic_kwargs["thinking"] = {
+                    "budget_tokens": thinking_config.thinking_budget,
+                    "type": "enabled",
+                }
+            else:
+                anthropic_kwargs["thinking"] = {
+                    "type": "disabled",
+                }
         
         if system_message is not None:
             anthropic_kwargs["system"] = system_message
@@ -440,7 +463,7 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
                     tool_choice_mode = tool_config.function_calling_config.mode
             anthropic_kwargs["tool_choice"] = {"type": tool_choice_mode.lower()}
         
-        if result_type is None or result_type == "text":
+        if result_type is None or result_type == "json":
             response = await self.client.messages.create(**anthropic_kwargs)
             
             parts: list[Part] = []
@@ -487,11 +510,14 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
                 ),
                 parsed=parsed_pydantic,
             )
+        else:
+            raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
     
     async def create_stream(
         self,
         messages: list[Content],
         *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> AsyncIterator[Response]:
@@ -515,6 +541,19 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
             "stream": True,
         }
         
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        if thinking_config is not None:
+            if thinking_config.include_thoughts:
+                anthropic_kwargs["thinking"] = {
+                    "budget_tokens": thinking_config.thinking_budget,
+                    "type": "enabled",
+                }
+            else:
+                anthropic_kwargs["thinking"] = {
+                    "type": "disabled",
+                }
+        
         if system_message is not None:
             anthropic_kwargs["system"] = system_message
         

promptbuilder/llm_client/base_client.py

@@ -6,7 +6,7 @@ import logging
 from abc import ABC, abstractmethod
 from typing import Iterator, AsyncIterator, Literal, overload
 
-from promptbuilder.llm_client.types import Response, Content, Part, Tool, ToolConfig, FunctionCall, FunctionCallingConfig, Json, ThinkingConfig, ApiKey, PydanticStructure, FinishReason
+from promptbuilder.llm_client.types import Response, Content, Part, Tool, ToolConfig, FunctionCall, FunctionCallingConfig, Json, ThinkingConfig, ApiKey, PydanticStructure, ResultType, FinishReason
 import promptbuilder.llm_client.utils as utils
 import promptbuilder.llm_client.logfire_decorators as logfire_decorators
 from promptbuilder.llm_client.config import GLOBAL_CONFIG
@@ -14,13 +14,18 @@ from promptbuilder.llm_client.config import GLOBAL_CONFIG
 
 logger = logging.getLogger(__name__)
 
-type ResultType = Literal["json"] | type[PydanticStructure] | None
-
-
 class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
     provider: str
     
-    def __init__(self, provider: str, model: str, decorator_configs: utils.DecoratorConfigs | None = None, default_max_tokens: int | None = None, **kwargs):
+    def __init__(
+        self,
+        provider: str,
+        model: str,
+        decorator_configs: utils.DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
+        default_max_tokens: int | None = None,
+        **kwargs,
+    ):
         self.provider = provider
         self.model = model
         
@@ -31,6 +36,11 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
                 decorator_configs = utils.DecoratorConfigs()
         self._decorator_configs = decorator_configs
         
+        if default_thinking_config is None:
+            if self.full_model_name in GLOBAL_CONFIG.default_thinking_configs:
+                default_thinking_config = GLOBAL_CONFIG.default_thinking_configs[self.full_model_name]
+        self.default_thinking_config = default_thinking_config
+        
         if default_max_tokens is None:
             if self.full_model_name in GLOBAL_CONFIG.default_max_tokens:
                 default_max_tokens = GLOBAL_CONFIG.default_max_tokens[self.full_model_name]
@@ -72,7 +82,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -86,7 +96,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: None = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -98,7 +108,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: Literal["json"],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -110,7 +120,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: type[PydanticStructure],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -122,7 +132,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: Literal["tools"],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool],
@@ -134,12 +144,12 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: ResultType | Literal["tools"] = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
         tool_choice_mode: Literal["ANY", "NONE"] = "NONE",
-        autocomplete: bool = False
+        autocomplete: bool = False,
     ):
         if result_type == "tools":
             response = self.create(
@@ -223,7 +233,14 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
     @logfire_decorators.create_stream
     @utils.retry_cls
     @utils.rpm_limit_cls
-    def create_stream(self, messages: list[Content], *, system_message: str | None = None, max_tokens: int | None = None) -> Iterator[Response]:
+    def create_stream(
+        self,
+        messages: list[Content],
+        *,
+        thinking_config: ThinkingConfig | None = None,
+        system_message: str | None = None,
+        max_tokens: int | None = None,
+    ) -> Iterator[Response]:
         raise NotImplementedError
     
     @overload
@@ -232,7 +249,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: None = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -244,7 +261,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: Literal["json"],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -256,7 +273,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: type[PydanticStructure],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -268,7 +285,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: Literal["tools"],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool],
@@ -280,7 +297,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: ResultType | Literal["tools"] = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -300,7 +317,15 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
 class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
     provider: str
     
-    def __init__(self, provider: str, model: str, decorator_configs: utils.DecoratorConfigs | None = None, default_max_tokens: int | None = None, **kwargs):
+    def __init__(
+        self,
+        provider: str,
+        model: str,
+        decorator_configs: utils.DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
+        default_max_tokens: int | None = None,
+        **kwargs,
+    ):
         self.provider = provider
         self.model = model
         
@@ -311,6 +336,11 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
                 decorator_configs = utils.DecoratorConfigs()
         self._decorator_configs = decorator_configs
         
+        if default_thinking_config is None:
+            if self.full_model_name in GLOBAL_CONFIG.default_thinking_configs:
+                default_thinking_config = GLOBAL_CONFIG.default_thinking_configs[self.full_model_name]
+        self.default_thinking_config = default_thinking_config
+        
         if default_max_tokens is None:
             if self.full_model_name in GLOBAL_CONFIG.default_max_tokens:
                 default_max_tokens = GLOBAL_CONFIG.default_max_tokens[self.full_model_name]
@@ -335,7 +365,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -349,7 +379,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: None = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -361,7 +391,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: Literal["json"],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -373,7 +403,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: type[PydanticStructure],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -385,7 +415,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: Literal["tools"],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool],
@@ -397,12 +427,12 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         messages: list[Content],
         result_type: ResultType | Literal["tools"] = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
         tool_choice_mode: Literal["ANY", "NONE"] = "NONE",
-        autocomplete: bool = False
+        autocomplete: bool = False,
     ):
         if result_type == "tools":
             response = await self.create(
@@ -457,7 +487,14 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
     @logfire_decorators.create_stream_async
     @utils.retry_cls_async
     @utils.rpm_limit_cls_async
-    async def create_stream(self, messages: list[Content], *, system_message: str | None = None, max_tokens: int | None = None) -> AsyncIterator[Response]:
+    async def create_stream(
+        self,
+        messages: list[Content],
+        *,
+        thinking_config: ThinkingConfig | None = None,
+        system_message: str | None = None,
+        max_tokens: int | None = None,
+    ) -> AsyncIterator[Response]:
         raise NotImplementedError
     
     @overload
@@ -466,7 +503,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: None = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -478,7 +515,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: Literal["json"],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -490,7 +527,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: type[PydanticStructure],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: None = None,
@@ -502,7 +539,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: Literal["tools"],
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool],
@@ -514,7 +551,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
         prompt: str,
         result_type: ResultType | Literal["tools"] = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -537,7 +574,13 @@ class CachedLLMClient(BaseLLMClient):
         return self.llm_client.api_key
 
     def __init__(self, llm_client: BaseLLMClient, cache_dir: str = "data/llm_cache"):
-        super().__init__(provider=llm_client.provider, model=llm_client.model, decorator_configs=llm_client._decorator_configs, default_max_tokens=llm_client.default_max_tokens)
+        super().__init__(
+            provider=llm_client.provider,
+            model=llm_client.model,
+            decorator_configs=llm_client._decorator_configs,
+            default_thinking_config=llm_client.default_thinking_config,
+            default_max_tokens=llm_client.default_max_tokens,
+        )
         self.provider = llm_client.provider
         self.llm_client = llm_client
         self.cache_dir = cache_dir

promptbuilder/llm_client/bedrock_client.py

@@ -53,6 +53,7 @@ class BedrockLLMClient(BaseLLMClient):
         model: str,
         api_key: BedrockApiKey = BedrockApiKey(),
         decorator_configs: DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
@@ -61,7 +62,7 @@ class BedrockLLMClient(BaseLLMClient):
                 "To create a bedrock llm client you need to either set the environment variables "
                 "AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and optional AWS_DEFAULT_REGION or pass the api_key as BedrockApiKey instance"
             )
-        super().__init__(BedrockLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+        super().__init__(BedrockLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
         self._api_key = api_key
     
     @property
@@ -73,7 +74,7 @@ class BedrockLLMClient(BaseLLMClient):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -230,6 +231,7 @@ class BedrockLLMClient(BaseLLMClient):
         self,
         messages: list[Content],
         *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> Iterator[Response]:
@@ -313,6 +315,7 @@ class BedrockLLMClientAsync(BaseLLMClientAsync):
         model: str,
         api_key: BedrockApiKey = BedrockApiKey(),
         decorator_configs: DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
@@ -321,7 +324,7 @@ class BedrockLLMClientAsync(BaseLLMClientAsync):
                 "To create a bedrock llm client you need to either set the environment variables "
                 "AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and optional AWS_DEFAULT_REGION or pass the api_key as BedrockApiKey instance"
             )
-        super().__init__(BedrockLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+        super().__init__(BedrockLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
         self._api_key = api_key
         self._aioboto_session = aioboto3.Session(
             aws_access_key_id=api_key.aws_access_key_id,
@@ -338,7 +341,7 @@ class BedrockLLMClientAsync(BaseLLMClientAsync):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -489,6 +492,7 @@ class BedrockLLMClientAsync(BaseLLMClientAsync):
         self,
         messages: list[Content],
         *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> AsyncIterator[Response]:

promptbuilder/llm_client/config.py

@@ -1,6 +1,7 @@
 import dataclasses
 
 from promptbuilder.llm_client.utils import DecoratorConfigs
+from promptbuilder.llm_client.types import ThinkingConfig
 
 
 @dataclasses.dataclass
@@ -9,6 +10,9 @@ class LlmClientConfigs:
     default_decorator_configs: dict[str, DecoratorConfigs] = dataclasses.field(default_factory=dict)
     """Dictionary mapping a client name to the default decorator configs to be used for that model."""
     
+    default_thinking_configs: dict[str, ThinkingConfig] = dataclasses.field(default_factory=dict)
+    """Dictionary mapping a client name to the default thinking config to be used for that model."""
+    
     default_max_tokens: dict[str, int] = dataclasses.field(default_factory=dict)
     """Dictionary mapping a client name to the default max_tokens value to be used for that model."""
     

promptbuilder/llm_client/google_client.py

@@ -17,12 +17,13 @@ class GoogleLLMClient(BaseLLMClient):
         model: str,
         api_key: str = os.getenv("GOOGLE_API_KEY"),
         decorator_configs: DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create a google llm client you need to either set the environment variable GOOGLE_API_KEY or pass the api_key in string format")
-        super().__init__(GoogleLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+        super().__init__(GoogleLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
         self._api_key = api_key
         self.client = Client(api_key=api_key)
     
@@ -58,7 +59,7 @@ class GoogleLLMClient(BaseLLMClient):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -74,10 +75,9 @@ class GoogleLLMClient(BaseLLMClient):
             tool_config=tool_config,
         )
         
-        if not thinking_config.include_thoughts:
-            thinking_config = ThinkingConfig(include_thoughts=False, thinking_budget=0)
-        if thinking_config.include_thoughts or "gemini-2.5-pro-preview-05-06" in self.model:
-            config.thinking_config = thinking_config
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        config.thinking_config = thinking_config
         
         if result_type is None:
             return self.client.models.generate_content(
@@ -108,6 +108,7 @@ class GoogleLLMClient(BaseLLMClient):
         self,
         messages: list[Content],
         *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> Iterator[Response]:
@@ -116,8 +117,12 @@ class GoogleLLMClient(BaseLLMClient):
         config = types.GenerateContentConfig(
             system_instruction=system_message,
             max_output_tokens=max_tokens,
-            thinking_config=ThinkingConfig(include_thoughts=False, thinking_budget=0),
         )
+        
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        config.thinking_config = thinking_config
+        
         response = self.client.models.generate_content_stream(
             model=self.model,
             contents=messages,
@@ -162,12 +167,13 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
         model: str,
         api_key: str = os.getenv("GOOGLE_API_KEY"),
         decorator_configs: DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create a google llm client you need to either set the environment variable GOOGLE_API_KEY or pass the api_key in string format")
-        super().__init__(GoogleLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+        super().__init__(GoogleLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
         self._api_key = api_key
         self.client = Client(api_key=api_key)
     
@@ -180,7 +186,7 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -196,10 +202,9 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
             tool_config=tool_config,
         )
         
-        if not thinking_config.include_thoughts:
-            thinking_config = ThinkingConfig(include_thoughts=False, thinking_budget=0)
-        if thinking_config.include_thoughts or "gemini-2.5" in self.model:
-            config.thinking_config = thinking_config
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        config.thinking_config = thinking_config
         
         if result_type is None or result_type == "json":
             return await self.client.aio.models.generate_content(
@@ -222,6 +227,7 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
         self,
         messages: list[Content],
         *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> AsyncIterator[Response]:
@@ -230,8 +236,12 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
         config = types.GenerateContentConfig(
             system_instruction=system_message,
             max_output_tokens=max_tokens,
-            thinking_config=ThinkingConfig(include_thoughts=False, thinking_budget=0),
         )
+        
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        config.thinking_config = thinking_config
+        
         response = await self.client.aio.models.generate_content_stream(
             model=self.model,
             contents=messages,

promptbuilder/llm_client/main.py

@@ -1,7 +1,7 @@
 import warnings
 from itertools import chain
 
-from promptbuilder.llm_client.types import ApiKey, Model
+from promptbuilder.llm_client.types import ApiKey, Model, ThinkingConfig
 from promptbuilder.llm_client.base_client import BaseLLMClient, BaseLLMClientAsync
 from promptbuilder.llm_client.config import GLOBAL_CONFIG
 from promptbuilder.llm_client.utils import DecoratorConfigs
@@ -17,41 +17,45 @@ _memory: dict[tuple[str, ApiKey], BaseLLMClient] = {}
 _memory_async: dict[tuple[str, ApiKey], BaseLLMClientAsync] = {}
 
 
-def get_client(full_model_name: str, api_key: ApiKey | None = None, decorator_configs: DecoratorConfigs | None = None, default_max_tokens: int | None = None) -> BaseLLMClient:
+def get_client(
+    full_model_name: str,
+    api_key: ApiKey | None = None,
+    decorator_configs: DecoratorConfigs | None = None,
+    default_thinking_config: ThinkingConfig | None = None,
+    default_max_tokens: int | None = None,
+) -> BaseLLMClient:
     global _memory
     
+    kwargs = {
+        "decorator_configs": decorator_configs,
+        "default_thinking_config": default_thinking_config,
+        "default_max_tokens": default_max_tokens,
+    }
+    provider_to_client_class: dict[str, type[BaseLLMClient]] = {
+        "google": GoogleLLMClient,
+        "anthropic": AnthropicLLMClient,
+        "openai": OpenaiLLMClient,
+        "bedrock": BedrockLLMClient,
+    }
     provider, model = full_model_name.split(":", 1)
-    match provider:
-        case "google":
-            if api_key is None:
-                client = GoogleLLMClient(model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-            else:
-                client = GoogleLLMClient(model, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-        case "anthropic":
-            if api_key is None:
-                client = AnthropicLLMClient(model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-            else:
-                client = AnthropicLLMClient(model, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-        case "openai":
-            if api_key is None:
-                client = OpenaiLLMClient(model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-            else:
-                client = OpenaiLLMClient(model, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-        case "bedrock":
-            if api_key is None:
-                client = BedrockLLMClient(model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-            else:
-                client = BedrockLLMClient(model, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-        case _:
-            if api_key is None:
-                raise ValueError(f"You should directly provide api_key for this provider: {provider}")
-            else:
-                client = AiSuiteLLMClient(full_model_name, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+    if provider in provider_to_client_class:
+        client_class = provider_to_client_class[provider]
+        if api_key is None:
+            client = client_class(model, **kwargs)
+        else:
+            client = client_class(model, api_key, **kwargs)
+    else:
+        if api_key is None:
+            raise ValueError(f"You should directly provide api_key for this provider: {provider}")
+        else:
+            client = AiSuiteLLMClient(full_model_name, api_key, **kwargs)
     
     if (full_model_name, client.api_key) in _memory:
         client = _memory[(full_model_name, client.api_key)]
         if decorator_configs is not None:
             client._decorator_configs = decorator_configs
+        if default_thinking_config is not None:
+            client.default_thinking_config = default_thinking_config
         if default_max_tokens is not None:
             client.default_max_tokens = default_max_tokens
         return client
@@ -60,42 +64,45 @@ def get_client(full_model_name: str, api_key: ApiKey | None = None, decorator_co
         return client
 
 
-def get_async_client(full_model_name: str, api_key: ApiKey | None = None, decorator_configs: DecoratorConfigs | None = None, default_max_tokens: int | None = None) -> BaseLLMClientAsync:
+def get_async_client(
+    full_model_name: str,
+    api_key: ApiKey | None = None,
+    decorator_configs: DecoratorConfigs | None = None,
+    default_thinking_config: ThinkingConfig | None = None,
+    default_max_tokens: int | None = None,
+) -> BaseLLMClientAsync:
     global _memory_async
     
-    
+    kwargs = {
+        "decorator_configs": decorator_configs,
+        "default_thinking_config": default_thinking_config,
+        "default_max_tokens": default_max_tokens,
+    }
+    provider_to_client_class: dict[str, type[BaseLLMClientAsync]] = {
+        "google": GoogleLLMClientAsync,
+        "anthropic": AnthropicLLMClientAsync,
+        "openai": OpenaiLLMClientAsync,
+        "bedrock": BedrockLLMClientAsync,
+    }
     provider, model = full_model_name.split(":", 1)
-    match provider:
-        case "google":
-            if api_key is None:
-                client = GoogleLLMClientAsync(model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-            else:
-                client = GoogleLLMClientAsync(model, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-        case "anthropic":
-            if api_key is None:
-                client = AnthropicLLMClientAsync(model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-            else:
-                client = AnthropicLLMClientAsync(model, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-        case "openai":
-            if api_key is None:
-                client = OpenaiLLMClientAsync(model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-            else:
-                client = OpenaiLLMClientAsync(model, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-        case "bedrock":
-            if api_key is None:
-                client = BedrockLLMClientAsync(model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-            else:
-                client = BedrockLLMClientAsync(model, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
-        case _:
-            if api_key is None:
-                raise ValueError(f"You should directly provide api_key for this provider: {provider}")
-            else:
-                client = AiSuiteLLMClientAsync(full_model_name, api_key, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+    if provider in provider_to_client_class:
+        client_class = provider_to_client_class[provider]
+        if api_key is None:
+            client = client_class(model, **kwargs)
+        else:
+            client = client_class(model, api_key, **kwargs)
+    else:
+        if api_key is None:
+            raise ValueError(f"You should directly provide api_key for this provider: {provider}")
+        else:
+            client = AiSuiteLLMClientAsync(full_model_name, api_key, **kwargs)
         
     if (full_model_name, client.api_key) in _memory_async:
         client = _memory_async[(full_model_name, client.api_key)]
         if decorator_configs is not None:
             client._decorator_configs = decorator_configs
+        if default_thinking_config is not None:
+            client.default_thinking_config = default_thinking_config
         if default_max_tokens is not None:
             client.default_max_tokens = default_max_tokens
         return client
@@ -130,6 +137,8 @@ def configure(
     *,
     decorator_configs: dict[str, DecoratorConfigs] | None = None,
     update_decorator_configs: dict[str, DecoratorConfigs] | None = None,
+    thinking_configs: dict[str, ThinkingConfig] | None = None,
+    update_thinking_configs: dict[str, ThinkingConfig] | None = None,
     max_tokens: dict[str, int] | None = None,
     update_max_tokens: dict[str, int] | None = None,
     use_logfire: bool | None = None,
@@ -138,6 +147,10 @@ def configure(
         warnings.warn("Both 'decorator_configs' and 'update_decorator_configs' were provided. "
                       "'update_decorator_configs' will be ignored.", UserWarning)
         update_decorator_configs = None
+    if thinking_configs is not None and update_thinking_configs is not None:
+        warnings.warn("Both 'thinking_configs' and 'update_thinking_configs' were provided. "
+                      "'update_thinking_configs' will be ignored.", UserWarning)
+        update_thinking_configs = None
     if max_tokens is not None and update_max_tokens is not None:
         warnings.warn("Both 'max_tokens' and 'update_max_tokens' were provided. "
                       "'update_max_tokens' will be ignored.", UserWarning)
@@ -148,6 +161,11 @@ def configure(
     if update_decorator_configs is not None:
         GLOBAL_CONFIG.default_decorator_configs.update(update_decorator_configs)
     
+    if thinking_configs is not None:
+        GLOBAL_CONFIG.default_thinking_configs = thinking_configs
+    if update_thinking_configs is not None:
+        GLOBAL_CONFIG.default_thinking_configs.update(update_thinking_configs)
+    
     if max_tokens is not None:
         GLOBAL_CONFIG.default_max_tokens = max_tokens
     if update_max_tokens is not None:
@@ -163,6 +181,11 @@ def sync_existing_clients_with_global_config():
         else:
             llm_client._decorator_configs = DecoratorConfigs()
         
+        if full_model_name in GLOBAL_CONFIG.default_thinking_configs:
+            llm_client.default_thinking_config = GLOBAL_CONFIG.default_thinking_configs[full_model_name]
+        else:
+            llm_client.default_thinking_config = None
+        
         if full_model_name in GLOBAL_CONFIG.default_max_tokens:
             llm_client.default_max_tokens = GLOBAL_CONFIG.default_max_tokens[full_model_name]
         else:

promptbuilder/llm_client/openai_client.py

@@ -45,12 +45,13 @@ class OpenaiLLMClient(BaseLLMClient):
         model: str,
         api_key: str = os.getenv("OPENAI_API_KEY"),
         decorator_configs: DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create an openai llm client you need to either set the environment variable OPENAI_API_KEY or pass the api_key in string format")
-        super().__init__(OpenaiLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+        super().__init__(OpenaiLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
         self._api_key = api_key
         self.client = OpenAI(api_key=api_key)
     
@@ -92,7 +93,10 @@ class OpenaiLLMClient(BaseLLMClient):
         return openai_messages
 
     @staticmethod
-    def _process_thinking_config(thinking_config: ThinkingConfig) -> dict[str, str]:
+    def _process_thinking_config(thinking_config: ThinkingConfig | None) -> dict[str, str]:
+        if thinking_config is None:
+            return {}
+        
         openai_thinking_config = {}
         if thinking_config.include_thoughts:
             # openai_thinking_config["summary"] = "auto"
@@ -114,7 +118,7 @@ class OpenaiLLMClient(BaseLLMClient):
         messages: list[Content],
         result_type: ResultType = None,
         *,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -131,6 +135,8 @@ class OpenaiLLMClient(BaseLLMClient):
             "input": openai_messages,
         }
         
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
         openai_kwargs.update(OpenaiLLMClient._process_thinking_config(thinking_config))
 
         if tools is not None:
@@ -222,6 +228,7 @@ class OpenaiLLMClient(BaseLLMClient):
         self,
         messages: list[Content],
         *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> Iterator[Response]:
@@ -235,6 +242,11 @@ class OpenaiLLMClient(BaseLLMClient):
             "max_output_tokens": max_tokens,
             "input": openai_messages,
         }
+        
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        openai_kwargs.update(OpenaiLLMClient._process_thinking_config(thinking_config))
+        
         response = self.client.responses.create(**openai_kwargs, stream=True)
         return OpenaiStreamIterator(response)
 
@@ -298,12 +310,13 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
         model: str,
         api_key: str = os.getenv("OPENAI_API_KEY"),
         decorator_configs: DecoratorConfigs | None = None,
+        default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create an openai llm client you need to either set the environment variable OPENAI_API_KEY or pass the api_key in string format")
-        super().__init__(OpenaiLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_max_tokens=default_max_tokens)
+        super().__init__(OpenaiLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
         self._api_key = api_key
         self.client = AsyncOpenAI(api_key=api_key)
     
@@ -315,7 +328,8 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
         self,
         messages: list[Content],
         result_type: ResultType = None,
-        thinking_config: ThinkingConfig = ThinkingConfig(),
+        *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
         tools: list[Tool] | None = None,
@@ -339,6 +353,8 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
             "input": openai_messages,
         }
         
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
         openai_kwargs.update(OpenaiLLMClient._process_thinking_config(thinking_config))
         
         if tools is not None:
@@ -377,7 +393,7 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
             elif tool_choice_mode == "ANY":
                 openai_kwargs["tool_choice"] = "required"
         
-        if result_type is None or result_type == "text":
+        if result_type is None or result_type == "json":
             response = await self.client.responses.create(**openai_kwargs)
             
             parts: list[Part] = []
@@ -423,11 +439,14 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
                 ),
                 parsed=parsed,
             )
+        else:
+            raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
         
     async def create_stream(
         self,
         messages: list[Content],
         *,
+        thinking_config: ThinkingConfig | None = None,
         system_message: str | None = None,
         max_tokens: int | None = None,
     ) -> AsyncIterator[Response]:
@@ -448,6 +467,11 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
             "max_output_tokens": max_tokens,
             "input": openai_messages,
         }
+        
+        if thinking_config is None:
+            thinking_config = self.default_thinking_config
+        openai_kwargs.update(OpenaiLLMClient._process_thinking_config(thinking_config))
+        
         response = await self.client.responses.create(**openai_kwargs, stream=True)
         return OpenaiStreamIteratorAsync(response)
 

promptbuilder/llm_client/types.py

@@ -14,6 +14,8 @@ type Json = list | dict
 type JsonType = Literal["string", "number", "integer", "boolean", "array", "object"]
 PydanticStructure = TypeVar("PydanticStructure", bound=BaseModel)
 
+type ResultType = Literal["json"] | type[PydanticStructure] | None
+
 
 class CustomApiKey(ABC):
     @abstractmethod

{promptbuilder-0.4.16.dist-info → promptbuilder-0.4.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: promptbuilder
-Version: 0.4.16
+Version: 0.4.18
 Summary: Library for building prompts for LLMs
 Home-page: https://github.com/kapulkin/promptbuilder
 Author: Kapulkin Stanislav
@@ -14,7 +14,7 @@ License-File: LICENSE
 Requires-Dist: pydantic
 Requires-Dist: pytest
 Requires-Dist: aisuite-async
-Requires-Dist: google-genai
+Requires-Dist: google-genai<=1.21.0,>=1.4.0
 Requires-Dist: anthropic
 Requires-Dist: openai
 Requires-Dist: aioboto3

promptbuilder-0.4.18.dist-info/RECORD

@@ -0,0 +1,24 @@
+promptbuilder/__init__.py,sha256=o_NdXl7NppM399-fy5VGfYkSN8iYDAaFAwJNhdkW3bI,56
+promptbuilder/prompt_builder.py,sha256=kK6WHr2umYmsanYb2fQVxqEajs_dzGPXRulTo40g36E,12428
+promptbuilder/agent/__init__.py,sha256=qG4Jq4wbmCH5NKLOX6ZMtZ7lFURhJXf464BntR-u5rU,56
+promptbuilder/agent/agent.py,sha256=dVu251C1r9w5LS2P_shsIRH9tFz1Jq93MDv3Uu41_4E,9274
+promptbuilder/agent/context.py,sha256=CVw715vFrhfvddQmRNy4A1U87GsZyIKj9Xu4SCidbc0,1120
+promptbuilder/agent/tool.py,sha256=VDbIHK3_Q62Ei7hwLF7nIgHq-PTMKnv1NSjHpDYkUZE,2651
+promptbuilder/agent/utils.py,sha256=vTkphKw04v_QDIJtoB2JKK0RGY6iI1t_0LbmuStunzI,356
+promptbuilder/llm_client/__init__.py,sha256=2tPVYqwNdwTRdIg4Pde6Nc259FJvy70gjEj1N2oqNrc,458
+promptbuilder/llm_client/aisuite_client.py,sha256=aMqg05zefzck9Lz7pm7jZoKFdzr_ymFYhrAjZtzdHlQ,15561
+promptbuilder/llm_client/anthropic_client.py,sha256=JeTVC26ahuJJT4G_3Bsoc4TqLzVDPuJpJiCRxTALnqA,26146
+promptbuilder/llm_client/base_client.py,sha256=GS-Qb20WtZnljmEUD2ibhTHDet7exoyhQ0_mGNAEKlg,24219
+promptbuilder/llm_client/bedrock_client.py,sha256=W4wFW7Vbv-nsT2ReyhJ4YIPSTXxE_4S83352vJDSmDk,25772
+promptbuilder/llm_client/config.py,sha256=exQEm35wp7lK5SfXNpN5H9VZEb2LVa4pyZ-cxGt1U-U,1124
+promptbuilder/llm_client/google_client.py,sha256=heyeACt_0bVP3p4pCQeWR92MhCsyNk844kWJ_0MVTfg,9830
+promptbuilder/llm_client/logfire_decorators.py,sha256=un_QnIekypOEcqTZ5v1y9pwijGnF95xwnwKO5rFSHVY,9667
+promptbuilder/llm_client/main.py,sha256=k4JTyKq2atNyFtI1bjjqXEnGSEugj4xk0AJEvHJiMig,8310
+promptbuilder/llm_client/openai_client.py,sha256=5yvjp-Zzp4JsBC9_ffSb1A9-iMG4Lu2B2et2CdtK9R0,22864
+promptbuilder/llm_client/types.py,sha256=2E-aPRb5uAkLFJocmjF1Lh2aQRq9r8a5JRIw-duHfjA,7460
+promptbuilder/llm_client/utils.py,sha256=79lvSppjrrItHB5MIozbp_5Oq7TsOK4Qzt9Ae3XMLFw,7624
+promptbuilder-0.4.18.dist-info/licenses/LICENSE,sha256=fqXmInzgsvEOIaKSBgcrwKyYCGYF0MKErJ0YivtODcc,1096
+promptbuilder-0.4.18.dist-info/METADATA,sha256=bbynjS91gKgHZKKCzw1VgD2FgI54Orn5OLRUqZJsQmA,3738
+promptbuilder-0.4.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+promptbuilder-0.4.18.dist-info/top_level.txt,sha256=UBVcYn4UgrPy3O3fmmnPEU_kieuplBMgheetIMei4EI,14
+promptbuilder-0.4.18.dist-info/RECORD,,

promptbuilder-0.4.16.dist-info/RECORD

@@ -1,24 +0,0 @@
-promptbuilder/__init__.py,sha256=o_NdXl7NppM399-fy5VGfYkSN8iYDAaFAwJNhdkW3bI,56
-promptbuilder/prompt_builder.py,sha256=kK6WHr2umYmsanYb2fQVxqEajs_dzGPXRulTo40g36E,12428
-promptbuilder/agent/__init__.py,sha256=qG4Jq4wbmCH5NKLOX6ZMtZ7lFURhJXf464BntR-u5rU,56
-promptbuilder/agent/agent.py,sha256=dVu251C1r9w5LS2P_shsIRH9tFz1Jq93MDv3Uu41_4E,9274
-promptbuilder/agent/context.py,sha256=CVw715vFrhfvddQmRNy4A1U87GsZyIKj9Xu4SCidbc0,1120
-promptbuilder/agent/tool.py,sha256=VDbIHK3_Q62Ei7hwLF7nIgHq-PTMKnv1NSjHpDYkUZE,2651
-promptbuilder/agent/utils.py,sha256=vTkphKw04v_QDIJtoB2JKK0RGY6iI1t_0LbmuStunzI,356
-promptbuilder/llm_client/__init__.py,sha256=2tPVYqwNdwTRdIg4Pde6Nc259FJvy70gjEj1N2oqNrc,458
-promptbuilder/llm_client/aisuite_client.py,sha256=Yvg2qnW182ksDoKKDeIpfx_oJTaZMSpwMBJ3KGh9Eek,15271
-promptbuilder/llm_client/anthropic_client.py,sha256=nt5kxqNXfsIkzaeBDm1eWDRC07mrLALALRAMbVmpP1Y,24309
-promptbuilder/llm_client/base_client.py,sha256=wmRSm5fhaoGCFIktkOTVJqDl78g5LVJI6JmzhSWk5JY,23174
-promptbuilder/llm_client/bedrock_client.py,sha256=nbyHQxLKl1nONNSnQtF9euj2kwBJb147fQetjU17Z38,25444
-promptbuilder/llm_client/config.py,sha256=Qgk9XeBGJdElY6cx91yz_e7eZJ_Ced6vAI9ByV_6lIA,858
-promptbuilder/llm_client/google_client.py,sha256=3w7g38r2NAP780nLZxegc3qQkIWEVUTRuQH6VvtKAEg,9606
-promptbuilder/llm_client/logfire_decorators.py,sha256=un_QnIekypOEcqTZ5v1y9pwijGnF95xwnwKO5rFSHVY,9667
-promptbuilder/llm_client/main.py,sha256=-naNScxlU-guvoPYJpThYNupGkl-ZQoViCGExDIR1gA,8566
-promptbuilder/llm_client/openai_client.py,sha256=y71LmgX0YzMJfj2yfao0rnbcbInjfOOrOj-twfAQk88,21696
-promptbuilder/llm_client/types.py,sha256=bb83O4YakOC8-JPk0W1HFUxEk_GJCpV_XPDJIAe890A,7390
-promptbuilder/llm_client/utils.py,sha256=79lvSppjrrItHB5MIozbp_5Oq7TsOK4Qzt9Ae3XMLFw,7624
-promptbuilder-0.4.16.dist-info/licenses/LICENSE,sha256=fqXmInzgsvEOIaKSBgcrwKyYCGYF0MKErJ0YivtODcc,1096
-promptbuilder-0.4.16.dist-info/METADATA,sha256=dT1ONqbFaFJLKuRH5c0eAom4TyL2IT2u56dj4ES1OAw,3722
-promptbuilder-0.4.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-promptbuilder-0.4.16.dist-info/top_level.txt,sha256=UBVcYn4UgrPy3O3fmmnPEU_kieuplBMgheetIMei4EI,14
-promptbuilder-0.4.16.dist-info/RECORD,,