Ignore leading whitespace when streaming from Qwen or DeepSeek (#2554)

Author: DouweM

docs/api/providers.md

@@ -35,3 +35,5 @@
 ::: pydantic_ai.providers.huggingface.HuggingFaceProvider
 
 ::: pydantic_ai.providers.moonshotai.MoonshotAIProvider
+
+::: pydantic_ai.providers.ollama.OllamaProvider

docs/models/openai.md

@@ -238,6 +238,8 @@ To use [Ollama](https://ollama.com/), you must first download the Ollama client,
 
 You must also ensure the Ollama server is running when trying to make requests to it. For more information, please see the [Ollama documentation](https://github.com/ollama/ollama/tree/main/docs).
 
+You can then use the model with the [`OllamaProvider`][pydantic_ai.providers.ollama.OllamaProvider].
+
 #### Example local usage
 
 With `ollama` installed, you can run the server with the model you want to use:
@@ -255,7 +257,7 @@ from pydantic import BaseModel
 
 from pydantic_ai import Agent
 from pydantic_ai.models.openai import OpenAIModel
-from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.providers.ollama import OllamaProvider
 
 
 class CityLocation(BaseModel):
@@ -264,7 +266,8 @@ class CityLocation(BaseModel):
 
 
 ollama_model = OpenAIModel(
-    model_name='llama3.2', provider=OpenAIProvider(base_url='http://localhost:11434/v1')
+    model_name='llama3.2',
+    provider=OllamaProvider(base_url='http://localhost:11434/v1'),
 )
 agent = Agent(ollama_model, output_type=CityLocation)
 
@@ -282,11 +285,11 @@ from pydantic import BaseModel
 
 from pydantic_ai import Agent
 from pydantic_ai.models.openai import OpenAIModel
-from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.providers.ollama import OllamaProvider
 
 ollama_model = OpenAIModel(
     model_name='qwen2.5-coder:7b',  # (1)!
-    provider=OpenAIProvider(base_url='http://192.168.1.74:11434/v1'),  # (2)!
+    provider=OllamaProvider(base_url='http://192.168.1.74:11434/v1'),  # (2)!
 )
 
 

pydantic_ai_slim/pydantic_ai/_parts_manager.py

@@ -72,6 +72,7 @@ def handle_text_delta(
         vendor_part_id: VendorId | None,
         content: str,
         thinking_tags: tuple[str, str] | None = None,
+        ignore_leading_whitespace: bool = False,
     ) -> ModelResponseStreamEvent | None:
         """Handle incoming text content, creating or updating a TextPart in the manager as appropriate.
 
@@ -85,6 +86,7 @@ def handle_text_delta(
                 a TextPart.
             content: The text content to append to the appropriate TextPart.
             thinking_tags: If provided, will handle content between the thinking tags as thinking parts.
+            ignore_leading_whitespace: If True, will ignore leading whitespace in the content.
 
         Returns:
             - A `PartStartEvent` if a new part was created.
@@ -128,10 +130,9 @@ def handle_text_delta(
             return self.handle_thinking_delta(vendor_part_id=vendor_part_id, content='')
 
         if existing_text_part_and_index is None:
-            # If the first text delta is all whitespace, don't emit a new part yet.
-            # This is a workaround for models that emit `<think>\n</think>\n\n` ahead of tool calls (e.g. Ollama + Qwen3),
-            # which we don't want to end up treating as a final result.
-            if content.isspace():
+            # This is a workaround for models that emit `<think>\n</think>\n\n` or an empty text part ahead of tool calls (e.g. Ollama + Qwen3),
+            # which we don't want to end up treating as a final result when using `run_stream` with `str` a valid `output_type`.
+            if ignore_leading_whitespace and (len(content) == 0 or content.isspace()):
                 return None
 
             # There is no existing text part that should be updated, so create a new one

pydantic_ai_slim/pydantic_ai/models/bedrock.py

@@ -648,7 +648,7 @@ async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
                         )
                 if 'text' in delta:
                     maybe_event = self._parts_manager.handle_text_delta(vendor_part_id=index, content=delta['text'])
-                    if maybe_event is not None:
+                    if maybe_event is not None:  # pragma: no branch
                         yield maybe_event
                 if 'toolUse' in delta:
                     tool_use = delta['toolUse']

pydantic_ai_slim/pydantic_ai/models/groq.py

@@ -457,6 +457,7 @@ async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
                     vendor_part_id='content',
                     content=content,
                     thinking_tags=self._model_profile.thinking_tags,
+                    ignore_leading_whitespace=self._model_profile.ignore_streamed_leading_whitespace,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai_slim/pydantic_ai/models/huggingface.py

@@ -35,7 +35,7 @@
     UserPromptPart,
     VideoUrl,
 )
-from ..profiles import ModelProfile
+from ..profiles import ModelProfile, ModelProfileSpec
 from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
@@ -121,20 +121,26 @@ def __init__(
         model_name: str,
         *,
         provider: Literal['huggingface'] | Provider[AsyncInferenceClient] = 'huggingface',
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a Hugging Face model.
 
         Args:
             model_name: The name of the Model to use. You can browse available models [here](https://huggingface.co/models?pipeline_tag=text-generation&inference_provider=all&sort=trending).
             provider: The provider to use for Hugging Face Inference Providers. Can be either the string 'huggingface' or an
                 instance of `Provider[AsyncInferenceClient]`. If not provided, the other parameters will be used.
+            profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+            settings: Model-specific settings that will be used as defaults for this model.
         """
         self._model_name = model_name
         self._provider = provider
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
 
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
+
     async def request(
         self,
         messages: list[ModelMessage],
@@ -444,11 +450,12 @@ async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
 
             # Handle the text part of the response
             content = choice.delta.content
-            if content:
+            if content is not None:
                 maybe_event = self._parts_manager.handle_text_delta(
                     vendor_part_id='content',
                     content=content,
                     thinking_tags=self._model_profile.thinking_tags,
+                    ignore_leading_whitespace=self._model_profile.ignore_streamed_leading_whitespace,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai_slim/pydantic_ai/models/openai.py

@@ -217,6 +217,7 @@ def __init__(
             'together',
             'heroku',
             'github',
+            'ollama',
         ]
         | Provider[AsyncOpenAI] = 'openai',
         profile: ModelProfileSpec | None = None,
@@ -1094,11 +1095,12 @@ async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
 
             # Handle the text part of the response
             content = choice.delta.content
-            if content:
+            if content is not None:
                 maybe_event = self._parts_manager.handle_text_delta(
                     vendor_part_id='content',
                     content=content,
                     thinking_tags=self._model_profile.thinking_tags,
+                    ignore_leading_whitespace=self._model_profile.ignore_streamed_leading_whitespace,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai_slim/pydantic_ai/profiles/__init__.py

@@ -20,7 +20,7 @@
 
 @dataclass
 class ModelProfile:
-    """Describes how requests to a specific model or family of models need to be constructed to get the best results, independent of the model and provider classes used."""
+    """Describes how requests to and responses from specific models or families of models need to be constructed and processed to get the best results, independent of the model and provider classes used."""
 
     supports_tools: bool = True
     """Whether the model supports tools."""
@@ -46,6 +46,15 @@ class ModelProfile:
     thinking_tags: tuple[str, str] = ('<think>', '</think>')
     """The tags used to indicate thinking parts in the model's output. Defaults to ('<think>', '</think>')."""
 
+    ignore_streamed_leading_whitespace: bool = False
+    """Whether to ignore leading whitespace when streaming a response.
+
+    This is a workaround for models that emit `<think>\n</think>\n\n` or an empty text part ahead of tool calls (e.g. Ollama + Qwen3),
+    which we don't want to end up treating as a final result when using `run_stream` with `str` a valid `output_type`.
+
+    This is currently only used by `OpenAIModel`, `HuggingFaceModel`, and `GroqModel`.
+    """
+
     @classmethod
     def from_profile(cls, profile: ModelProfile | None) -> Self:
         """Build a ModelProfile subclass instance from a ModelProfile instance."""

pydantic_ai_slim/pydantic_ai/profiles/deepseek.py

@@ -5,4 +5,4 @@
 
 def deepseek_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for a DeepSeek model."""
-    return None
+    return ModelProfile(ignore_streamed_leading_whitespace='r1' in model_name)

pydantic_ai_slim/pydantic_ai/profiles/moonshotai.py

@@ -5,4 +5,4 @@
 
 def moonshotai_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for a MoonshotAI model."""
-    return None
+    return ModelProfile(ignore_streamed_leading_whitespace=True)