promptbuilder 0.4.34__tar.gz → 0.4.36__tar.gz

{promptbuilder-0.4.34/promptbuilder.egg-info → promptbuilder-0.4.36}/PKG-INFO

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

{promptbuilder-0.4.34 → promptbuilder-0.4.36}/promptbuilder/llm_client/anthropic_client.py

@@ -313,7 +313,7 @@ class AnthropicLLMClient(BaseLLMClient):
             raise ValueError(f"Unsupported result type: {result_type}")
     
     @_error_handler
-    def create_stream(
+    def _create_stream(
         self,
         messages: list[Content],
         *,
@@ -576,7 +576,7 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
     
     @_error_handler_async
-    async def create_stream(
+    async def _create_stream(
         self,
         messages: list[Content],
         *,

{promptbuilder-0.4.34 → promptbuilder-0.4.36}/promptbuilder/llm_client/base_client.py

@@ -108,7 +108,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 autocomplete and response.candidates and finish_reason == FinishReason.MAX_TOKENS.value:
+            while response.candidates and finish_reason == FinishReason.MAX_TOKENS.value:
                 BaseLLMClient._append_generated_part(messages, response)
 
                 response = self._create(
@@ -296,7 +296,7 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
     @logfire_decorators.create_stream
     @utils.retry_cls
     @utils.rpm_limit_cls
-    def create_stream(
+    def _create_stream(
         self,
         messages: list[Content],
         *,
@@ -306,6 +306,47 @@ class BaseLLMClient(ABC, utils.InheritDecoratorsMixin):
     ) -> Iterator[Response]:
         raise NotImplementedError
     
+    def create_stream(
+        self,
+        messages: list[Content],
+        *,
+        thinking_config: ThinkingConfig | None = None,
+        system_message: str | None = None,
+        max_tokens: int | None = None,
+        autocomplete: bool = False,
+    ) -> Iterator[Response]:
+        if max_tokens is None:
+            max_tokens = self.default_max_tokens
+        
+        stream_messages = []
+
+        total_count = 0
+        response = None
+        for response in self._create_stream(
+            messages=messages,
+            thinking_config=thinking_config,
+            system_message=system_message,
+            max_tokens=max_tokens if not autocomplete else None,
+        ):
+            BaseLLMClient._append_generated_part(stream_messages, response)
+            total_count += BaseLLMClient._response_out_tokens(response)
+            yield response
+        finish_reason = response.candidates[0].finish_reason.value if response and response.candidates and response.candidates[0].finish_reason else None
+        if finish_reason and autocomplete:
+            while response.candidates and finish_reason == FinishReason.MAX_TOKENS.value:
+                for response in self._create_stream(
+                    messages=messages,
+                    thinking_config=thinking_config,
+                    system_message=system_message,
+                    max_tokens=max_tokens if not autocomplete else None,
+                ):
+                    BaseLLMClient._append_generated_part(stream_messages, response)
+                    total_count += BaseLLMClient._response_out_tokens(response)
+                    yield response
+                finish_reason = response.candidates[0].finish_reason.value if response.candidates and response.candidates[0].finish_reason else None
+                if max_tokens is not None and total_count >= max_tokens:
+                    break
+
     @overload
     def from_text(
         self,
@@ -459,7 +500,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 autocomplete and response.candidates and finish_reason == FinishReason.MAX_TOKENS.value:
+            while response.candidates and finish_reason == FinishReason.MAX_TOKENS.value:
                 BaseLLMClient._append_generated_part(messages, response)
 
                 response = await self._create(
@@ -609,7 +650,7 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
     @logfire_decorators.create_stream_async
     @utils.retry_cls_async
     @utils.rpm_limit_cls_async
-    async def create_stream(
+    async def _create_stream(
         self,
         messages: list[Content],
         *,
@@ -619,6 +660,48 @@ class BaseLLMClientAsync(ABC, utils.InheritDecoratorsMixin):
     ) -> AsyncIterator[Response]:
         raise NotImplementedError
     
+    async def create_stream(
+        self,
+        messages: list[Content],
+        *,
+        thinking_config: ThinkingConfig | None = None,
+        system_message: str | None = None,
+        max_tokens: int | None = None,
+        autocomplete: bool = False,
+    ) -> AsyncIterator[Response]:          
+        if max_tokens is None:
+            max_tokens = self.default_max_tokens
+        
+        total_count = 0
+        stream_iter = await self._create_stream(
+            messages=messages,
+            thinking_config=thinking_config,
+            system_message=system_message,
+            max_tokens=max_tokens if not autocomplete else None,
+        )
+        response = None
+        async for response in stream_iter:
+            BaseLLMClient._append_generated_part(messages, response)
+            total_count += BaseLLMClient._response_out_tokens(response)
+            yield response
+        
+        finish_reason = response.candidates[0].finish_reason.value if response and response.candidates and response.candidates[0].finish_reason else None
+        if finish_reason and autocomplete:
+            while response.candidates and finish_reason == FinishReason.MAX_TOKENS.value:
+                stream_iter = await self._create_stream(
+                    messages=messages,
+                    thinking_config=thinking_config,
+                    system_message=system_message,
+                    max_tokens=max_tokens if not autocomplete else None,
+                )
+                async for response in stream_iter:
+                    yield response
+                    BaseLLMClient._append_generated_part(messages, response)
+                    total_count += BaseLLMClient._response_out_tokens(response)
+                finish_reason = response.candidates[0].finish_reason.value if response.candidates and response.candidates[0].finish_reason else None
+                if max_tokens is not None and total_count >= max_tokens:
+                    break
+
     @overload
     async def from_text(
         self,

{promptbuilder-0.4.34 → promptbuilder-0.4.36}/promptbuilder/llm_client/bedrock_client.py

@@ -266,7 +266,7 @@ class BedrockLLMClient(BaseLLMClient):
             )
     
     @_error_handler
-    def create_stream(
+    def _create_stream(
         self,
         messages: list[Content],
         *,
@@ -560,7 +560,7 @@ class BedrockLLMClientAsync(BaseLLMClientAsync):
                 )
     
     @_error_handler_async
-    async def create_stream(
+    async def _create_stream(
         self,
         messages: list[Content],
         *,

{promptbuilder-0.4.34 → promptbuilder-0.4.36}/promptbuilder/llm_client/google_client.py

@@ -142,7 +142,7 @@ class GoogleLLMClient(BaseLLMClient):
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
     
     @_error_handler
-    def create_stream(
+    def _create_stream(
         self,
         messages: list[Content],
         *,
@@ -163,7 +163,7 @@ class GoogleLLMClient(BaseLLMClient):
         
         response = self.client.models.generate_content_stream(
             model=self.model,
-            contents=messages,
+            contents=[msg.model_dump() for msg in  messages],
             config=config,
         )
         return response
@@ -290,7 +290,7 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
     
     @_error_handler_async
-    async def create_stream(
+    async def _create_stream(
         self,
         messages: list[Content],
         *,
@@ -311,7 +311,7 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
         
         response = await self.client.aio.models.generate_content_stream(
             model=self.model,
-            contents=messages,
+            contents=[msg.model_dump() for msg in  messages],
             config=config,
         )
         return response

{promptbuilder-0.4.34 → promptbuilder-0.4.36}/promptbuilder/llm_client/litellm_client.py

@@ -241,7 +241,7 @@ class LiteLLMClient(BaseLLMClient):
                     finish_reason_val = first_choice.get("finish_reason")
                 else:
                     finish_reason_val = getattr(first_choice, "finish_reason", None)
-            mapped_finish_reason = LiteLLMClient._map_finish_reason(finish_reason_val)
+            mapped_finish_reason = LiteLLMLLMClient._map_finish_reason(finish_reason_val)
 
             content_parts: list[Part | Any] = list(parts)
             return Response(
@@ -293,7 +293,7 @@ class LiteLLMClient(BaseLLMClient):
                     finish_reason_val = first_choice.get("finish_reason")
                 else:
                     finish_reason_val = getattr(first_choice, "finish_reason", None)
-            mapped_finish_reason = LiteLLMClient._map_finish_reason(finish_reason_val)
+            mapped_finish_reason = LiteLLMLLMClient._map_finish_reason(finish_reason_val)
 
             content_parts2: list[Part | Any] = list(parts)
             return Response(
@@ -310,6 +310,125 @@ class LiteLLMClient(BaseLLMClient):
         else:
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
 
+    def _create_stream(
+        self,
+        messages: list[Content],
+        *,
+        thinking_config: ThinkingConfig | None = None,
+        system_message: str | None = None,
+        max_tokens: int | None = None,
+        timeout: float | None = None,
+        tools: list[Tool] | None = None,
+        tool_config: ToolConfig = ToolConfig(),
+    ):
+        """Streaming variant: yields Response objects with partial text/function calls.
+
+        Only supports plain text/function-call streaming (no structured pydantic parsing mid-stream).
+        Final yielded Response contains usage + finish_reason.
+        """
+        litellm_messages: list[dict[str, str]] = []
+        if system_message is not None:
+            litellm_messages.append({"role": "system", "content": system_message})
+        for message in messages:
+            if message.role == "user":
+                litellm_messages.append({"role": "user", "content": message.as_str()})
+            elif message.role == "model":
+                litellm_messages.append({"role": "assistant", "content": message.as_str()})
+
+        litellm_model = f"{self.provider}/{self.model}"
+        kwargs: dict[str, Any] = {
+            "model": litellm_model,
+            "messages": litellm_messages,
+            "stream": True,
+        }
+        if self._api_key:
+            kwargs["api_key"] = self._api_key
+        if self.provider == "ollama":
+            base_url = os.getenv("OLLAMA_BASE_URL") or os.getenv("LITELLM_OLLAMA_BASE_URL")
+            if base_url:
+                kwargs["api_base"] = base_url
+        if max_tokens is not None:
+            kwargs["max_tokens"] = max_tokens
+        if timeout is not None:
+            kwargs["request_timeout"] = timeout
+
+        if tools is not None:
+            lite_tools = []
+            allowed_function_names = None
+            if tool_config.function_calling_config is not None:
+                allowed_function_names = tool_config.function_calling_config.allowed_function_names
+            for tool in tools:
+                for func_decl in tool.function_declarations or []:
+                    if allowed_function_names is None or func_decl.name in allowed_function_names:
+                        parameters = func_decl.parameters
+                        if parameters is not None:
+                            parameters = parameters.model_dump(exclude_none=True)
+                        else:
+                            parameters = {"type": "object", "properties": {}, "required": [], "additionalProperties": False}
+                        lite_tools.append({
+                            "type": "function",
+                            "function": {
+                                "name": func_decl.name,
+                                "description": func_decl.description,
+                                "parameters": parameters,
+                            },
+                        })
+            if lite_tools:
+                kwargs["tools"] = lite_tools
+
+        stream_iter = litellm.completion(**kwargs)
+        # LiteLLM returns a generator of events / chunks.
+        # We'll accumulate text, track usage and finish_reason when present.
+        accumulated_parts: list[Part] = []
+        final_usage = None
+        finish_reason_val = None
+
+        for chunk in stream_iter:  # type: ignore
+            # Attempt to extract delta content (OpenAI style)
+            choices = getattr(chunk, "choices", None) or (chunk.get("choices") if isinstance(chunk, dict) else None)
+            if choices:
+                delta_choice = choices[0]
+                # finish_reason may appear early; capture last non-null
+                fr = None
+                if isinstance(delta_choice, dict):
+                    fr = delta_choice.get("finish_reason")
+                    delta_msg = delta_choice.get("delta") or delta_choice.get("message") or {}
+                else:
+                    fr = getattr(delta_choice, "finish_reason", None)
+                    delta_msg = getattr(delta_choice, "delta", None) or getattr(delta_choice, "message", None) or {}
+                if fr is not None:
+                    finish_reason_val = fr
+                # Handle tool calls if present in streaming (rare - ignoring detailed incremental args for now)
+                content_piece = None
+                if isinstance(delta_msg, dict):
+                    content_piece = delta_msg.get("content")
+                else:
+                    content_piece = getattr(delta_msg, "content", None)
+                if content_piece:
+                    accumulated_parts.append(Part(text=content_piece))
+                    yield Response(candidates=[Candidate(content=Content(parts=[Part(text=content_piece)], role="model"))])
+            # Usage may appear at final chunk in some providers (OpenAI style: usage object)
+            # Collect usage if present as attribute or key
+            usage_obj = None
+            if isinstance(chunk, dict):
+                usage_obj = chunk.get("usage")
+            else:
+                usage_obj = getattr(chunk, "usage", None)
+            if usage_obj is not None:
+                final_usage = usage_obj
+
+        # After stream ends, emit final Response with aggregated parts, usage, and finish_reason
+        usage_md = self.make_usage_metadata(final_usage)
+        mapped_finish_reason = LiteLLMClient._map_finish_reason(finish_reason_val)
+        final_parts: list[Part | Any] = list(accumulated_parts)
+        yield Response(
+            candidates=[Candidate(
+                content=Content(parts=final_parts, role="model"),
+                finish_reason=mapped_finish_reason,
+            )],
+            usage_metadata=usage_md,
+        )
+
 
 class LiteLLMClientAsync(BaseLLMClientAsync):
     provider: str = ""
@@ -341,11 +460,11 @@ class LiteLLMClientAsync(BaseLLMClientAsync):
 
     @staticmethod
     def make_function_call(tool_call) -> FunctionCall | None:
-        return LiteLLMClient.make_function_call(tool_call)
+        return LiteLLMLLMClient.make_function_call(tool_call)
 
     @staticmethod
     def make_usage_metadata(usage) -> UsageMetadata:
-        return LiteLLMClient.make_usage_metadata(usage)
+        return LiteLLMLLMClient.make_usage_metadata(usage)
 
     async def _create(
         self,
@@ -450,7 +569,7 @@ class LiteLLMClientAsync(BaseLLMClientAsync):
                     finish_reason_val = first_choice.get("finish_reason")
                 else:
                     finish_reason_val = getattr(first_choice, "finish_reason", None)
-            mapped_finish_reason = LiteLLMClient._map_finish_reason(finish_reason_val)
+            mapped_finish_reason = LiteLLMLLMClient._map_finish_reason(finish_reason_val)
 
             content_parts3: list[Part | Any] = list(parts)
             return Response(
@@ -502,7 +621,7 @@ class LiteLLMClientAsync(BaseLLMClientAsync):
                     finish_reason_val = first_choice.get("finish_reason")
                 else:
                     finish_reason_val = getattr(first_choice, "finish_reason", None)
-            mapped_finish_reason = LiteLLMClient._map_finish_reason(finish_reason_val)
+            mapped_finish_reason = LiteLLMLLMClient._map_finish_reason(finish_reason_val)
 
             content_parts4: list[Part | Any] = list(parts)
             return Response(
@@ -518,3 +637,111 @@ class LiteLLMClientAsync(BaseLLMClientAsync):
             )
         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,
+        timeout: float | None = None,
+        tools: list[Tool] | None = None,
+        tool_config: ToolConfig = ToolConfig(),
+    ):
+        """Async streaming variant mirroring sync version."""
+        litellm_messages: list[dict[str, str]] = []
+        if system_message is not None:
+            litellm_messages.append({"role": "system", "content": system_message})
+        for message in messages:
+            if message.role == "user":
+                litellm_messages.append({"role": "user", "content": message.as_str()})
+            elif message.role == "model":
+                litellm_messages.append({"role": "assistant", "content": message.as_str()})
+
+        litellm_model = f"{self.provider}/{self.model}"
+        kwargs: dict[str, Any] = {
+            "model": litellm_model,
+            "messages": litellm_messages,
+            "stream": True,
+        }
+        if self._api_key:
+            kwargs["api_key"] = self._api_key
+        if self.provider == "ollama":
+            base_url = os.getenv("OLLAMA_BASE_URL") or os.getenv("LITELLM_OLLAMA_BASE_URL")
+            if base_url:
+                kwargs["api_base"] = base_url
+        if max_tokens is not None:
+            kwargs["max_tokens"] = max_tokens
+        if timeout is not None:
+            kwargs["request_timeout"] = timeout
+
+        if tools is not None:
+            lite_tools = []
+            allowed_function_names = None
+            if tool_config.function_calling_config is not None:
+                allowed_function_names = tool_config.function_calling_config.allowed_function_names
+            for tool in tools:
+                for func_decl in tool.function_declarations or []:
+                    if allowed_function_names is None or func_decl.name in allowed_function_names:
+                        parameters = func_decl.parameters
+                        if parameters is not None:
+                            parameters = parameters.model_dump(exclude_none=True)
+                        else:
+                            parameters = {"type": "object", "properties": {}, "required": [], "additionalProperties": False}
+                        lite_tools.append({
+                            "type": "function",
+                            "function": {
+                                "name": func_decl.name,
+                                "description": func_decl.description,
+                                "parameters": parameters,
+                            },
+                        })
+            if lite_tools:
+                kwargs["tools"] = lite_tools
+
+        stream_iter = await litellm.acompletion(**kwargs)
+
+        accumulated_parts: list[Part] = []
+        final_usage = None
+        finish_reason_val = None
+
+        async for chunk in stream_iter:  # type: ignore
+            choices = getattr(chunk, "choices", None) or (chunk.get("choices") if isinstance(chunk, dict) else None)
+            if choices:
+                delta_choice = choices[0]
+                fr = None
+                if isinstance(delta_choice, dict):
+                    fr = delta_choice.get("finish_reason")
+                    delta_msg = delta_choice.get("delta") or delta_choice.get("message") or {}
+                else:
+                    fr = getattr(delta_choice, "finish_reason", None)
+                    delta_msg = getattr(delta_choice, "delta", None) or getattr(delta_choice, "message", None) or {}
+                if fr is not None:
+                    finish_reason_val = fr
+                content_piece = None
+                if isinstance(delta_msg, dict):
+                    content_piece = delta_msg.get("content")
+                else:
+                    content_piece = getattr(delta_msg, "content", None)
+                if content_piece:
+                    accumulated_parts.append(Part(text=content_piece))
+                    yield Response(candidates=[Candidate(content=Content(parts=[Part(text=content_piece)], role="model"))])
+            usage_obj = None
+            if isinstance(chunk, dict):
+                usage_obj = chunk.get("usage")
+            else:
+                usage_obj = getattr(chunk, "usage", None)
+            if usage_obj is not None:
+                final_usage = usage_obj
+
+        usage_md = self.make_usage_metadata(final_usage)
+        mapped_finish_reason = LiteLLMClient._map_finish_reason(finish_reason_val)
+        final_parts_async: list[Part | Any] = list(accumulated_parts)
+        yield Response(
+            candidates=[Candidate(
+                content=Content(parts=final_parts_async, role="model"),
+                finish_reason=mapped_finish_reason,
+            )],
+            usage_metadata=usage_md,
+        )

{promptbuilder-0.4.34 → promptbuilder-0.4.36}/promptbuilder/llm_client/logfire_decorators.py

@@ -54,6 +54,21 @@ def extract_response_data(response: Response) -> dict[str, Any]:
     return response_data
 
 
+def record(span: logfire.LogfireSpan, duration: float, response: Response):
+    span.set_attribute("duration", duration)
+
+    span.set_attribute("response_data", extract_response_data(response))
+    span.set_attribute("candidates", response.candidates)
+    span.set_attribute("parsed", response.parsed)
+    span.set_attribute("response_text", response.text)
+    if response.usage_metadata is not None:
+        span.set_attribute("usage_metadata.cached_content_token_count", response.usage_metadata.cached_content_token_count)
+        span.set_attribute("usage_metadata.candidates_token_count", response.usage_metadata.candidates_token_count)
+        span.set_attribute("usage_metadata.thoughts_token_count", response.usage_metadata.thoughts_token_count)
+        span.set_attribute("usage_metadata.prompt_token_count", response.usage_metadata.prompt_token_count)
+        span.set_attribute("usage_metadata.total_token_count", response.usage_metadata.total_token_count)
+
+
 @inherited_decorator
 def create(class_method: Callable[P, Response]) -> Callable[P, Response]:
     """
@@ -69,17 +84,7 @@ def create(class_method: Callable[P, Response]) -> Callable[P, Response]:
         with logfire_llm.span(f"Create with {span_data["full_model_name"]}", **span_data) as span:
             start_time = time.time()
             response = class_method(self, *args, **kwargs)
-            span.set_attribute("duration", time.time() - start_time)
-            
-            span.set_attribute("response_data", extract_response_data(response))
-            span.set_attribute("candidates", response.candidates)
-            span.set_attribute("parsed", response.parsed)
-            span.set_attribute("response_text", response.text)
-            if response.usage_metadata is not None:
-                span.set_attribute("usage_metadata.cached_content_token_count", response.usage_metadata.cached_content_token_count)
-                span.set_attribute("usage_metadata.candidates_token_count", response.usage_metadata.candidates_token_count)
-                span.set_attribute("usage_metadata.prompt_token_count", response.usage_metadata.prompt_token_count)
-                span.set_attribute("usage_metadata.total_token_count", response.usage_metadata.total_token_count)
+            record(span, time.time() - start_time, response)
             
             return response
     
@@ -101,17 +106,7 @@ def create_async(class_method: Callable[P, Awaitable[Response]]) -> Callable[P,
         with logfire_llm.span(f"Async create with {span_data["full_model_name"]}", **span_data) as span:
             start_time = time.time()
             response = await class_method(self, *args, **kwargs)
-            span.set_attribute("duration", time.time() - start_time)
-            
-            span.set_attribute("response_data", extract_response_data(response))
-            span.set_attribute("candidates", response.candidates)
-            span.set_attribute("parsed", response.parsed)
-            span.set_attribute("response_text", response.text)
-            if response.usage_metadata is not None:
-                span.set_attribute("usage_metadata.cached_content_token_count", response.usage_metadata.cached_content_token_count)
-                span.set_attribute("usage_metadata.candidates_token_count", response.usage_metadata.candidates_token_count)
-                span.set_attribute("usage_metadata.prompt_token_count", response.usage_metadata.prompt_token_count)
-                span.set_attribute("usage_metadata.total_token_count", response.usage_metadata.total_token_count)
+            record(span, time.time() - start_time, response)
             
             return response
             
@@ -150,6 +145,7 @@ def record_streaming(span: logfire.LogfireSpan):
         span.set_attribute("response_text", stream_state.get_response_data()["message"]["content"])
         span.set_attribute("usage_metadata.cached_content_token_count", stream_state.last_usage_data.cached_content_token_count)
         span.set_attribute("usage_metadata.candidates_token_count", stream_state.last_usage_data.candidates_token_count)
+        span.set_attribute("usage_metadata.thoughts_token_count", stream_state.last_usage_data.thoughts_token_count)
         span.set_attribute("usage_metadata.prompt_token_count", stream_state.last_usage_data.prompt_token_count)
         span.set_attribute("usage_metadata.total_token_count", stream_state.last_usage_data.total_token_count)
 

{promptbuilder-0.4.34 → promptbuilder-0.4.36}/promptbuilder/llm_client/openai_client.py

@@ -260,7 +260,7 @@ class OpenaiLLMClient(BaseLLMClient):
             raise ValueError(f"Unsupported result type: {result_type}. Supported types are None, 'json', or a Pydantic model class.")
     
     @_error_handler
-    def create_stream(
+    def _create_stream(
         self,
         messages: list[Content],
         *,
@@ -506,7 +506,7 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
     
     @_error_handler_async
-    async def create_stream(
+    async def _create_stream(
         self,
         messages: list[Content],
         *,

{promptbuilder-0.4.34 → promptbuilder-0.4.36/promptbuilder.egg-info}/PKG-INFO

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

{promptbuilder-0.4.34 → promptbuilder-0.4.36}/setup.py

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