pydantic-ai 0.0.48__tar.gz → 0.0.49__tar.gz

{pydantic_ai-0.0.48 → pydantic_ai-0.0.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 0.0.48
+Version: 0.0.49
 Summary: Agent Framework / shim to use Pydantic with LLMs
 Project-URL: Homepage, https://ai.pydantic.dev
 Project-URL: Source, https://github.com/pydantic/pydantic-ai
@@ -28,9 +28,9 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
-Requires-Dist: pydantic-ai-slim[anthropic,bedrock,cli,cohere,evals,groq,mcp,mistral,openai,vertexai]==0.0.48
+Requires-Dist: pydantic-ai-slim[anthropic,bedrock,cli,cohere,evals,groq,mcp,mistral,openai,vertexai]==0.0.49
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==0.0.48; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==0.0.49; extra == 'examples'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Description-Content-Type: text/markdown

{pydantic_ai-0.0.48 → pydantic_ai-0.0.49}/tests/evals/test_dataset.py

@@ -164,16 +164,12 @@ async def test_add_evaluator(
         'cases': [
             {
                 'evaluators': [{'Python': 'ctx.output == 2'}],
-                'expected_output': None,
                 'inputs': {'query': 'What is 1+1?'},
-                'metadata': None,
                 'name': 'My Case 1',
             },
             {
                 'evaluators': [{'Python': 'ctx.output == 4'}],
-                'expected_output': None,
                 'inputs': {'query': 'What is 2+2?'},
-                'metadata': None,
                 'name': 'My Case 2',
             },
         ],

{pydantic_ai-0.0.48 → pydantic_ai-0.0.49}/tests/evals/test_otel.py

@@ -245,26 +245,26 @@ async def test_span_tree_repr(span_tree: SpanTree):
 """)
     assert span_tree.repr_xml(include_span_id=True) == snapshot("""\
 <SpanTree>
-  <SpanNode name='root' span_id=0000000000000001 >
-    <SpanNode name='child1' span_id=0000000000000003 >
-      <SpanNode name='grandchild1' span_id=0000000000000005 />
-      <SpanNode name='grandchild2' span_id=0000000000000007 />
+  <SpanNode name='root' span_id='0000000000000001' >
+    <SpanNode name='child1' span_id='0000000000000003' >
+      <SpanNode name='grandchild1' span_id='0000000000000005' />
+      <SpanNode name='grandchild2' span_id='0000000000000007' />
     </SpanNode>
-    <SpanNode name='child2' span_id=0000000000000009 >
-      <SpanNode name='grandchild3' span_id=000000000000000b />
+    <SpanNode name='child2' span_id='0000000000000009' >
+      <SpanNode name='grandchild3' span_id='000000000000000b' />
     </SpanNode>
   </SpanNode>
 </SpanTree>\
 """)
     assert span_tree.repr_xml(include_trace_id=True) == snapshot("""\
 <SpanTree>
-  <SpanNode name='root' trace_id=00000000000000000000000000000001 >
-    <SpanNode name='child1' trace_id=00000000000000000000000000000001 >
-      <SpanNode name='grandchild1' trace_id=00000000000000000000000000000001 />
-      <SpanNode name='grandchild2' trace_id=00000000000000000000000000000001 />
+  <SpanNode name='root' trace_id='00000000000000000000000000000001' >
+    <SpanNode name='child1' trace_id='00000000000000000000000000000001' >
+      <SpanNode name='grandchild1' trace_id='00000000000000000000000000000001' />
+      <SpanNode name='grandchild2' trace_id='00000000000000000000000000000001' />
     </SpanNode>
-    <SpanNode name='child2' trace_id=00000000000000000000000000000001 >
-      <SpanNode name='grandchild3' trace_id=00000000000000000000000000000001 />
+    <SpanNode name='child2' trace_id='00000000000000000000000000000001' >
+      <SpanNode name='grandchild3' trace_id='00000000000000000000000000000001' />
     </SpanNode>
   </SpanNode>
 </SpanTree>\
@@ -302,9 +302,9 @@ async def test_span_node_repr(span_tree: SpanTree):
     assert node is not None
 
     leaf_node = span_tree.first({'name_equals': 'grandchild1'})
-    assert str(leaf_node) == snapshot("<SpanNode name='grandchild1' span_id=0000000000000005 />")
+    assert str(leaf_node) == snapshot("<SpanNode name='grandchild1' span_id='0000000000000005' />")
 
-    assert str(node) == snapshot("<SpanNode name='child2' span_id=0000000000000009>...</SpanNode>")
+    assert str(node) == snapshot("<SpanNode name='child2' span_id='0000000000000009'>...</SpanNode>")
     assert repr(node) == snapshot("""\
 <SpanNode name='child2' >
   <SpanNode name='grandchild3' />
@@ -312,13 +312,13 @@ async def test_span_node_repr(span_tree: SpanTree):
 """)
     assert node.repr_xml(include_children=False) == snapshot("<SpanNode name='child2' children=... />")
     assert node.repr_xml(include_span_id=True) == snapshot("""\
-<SpanNode name='child2' span_id=0000000000000009 >
-  <SpanNode name='grandchild3' span_id=000000000000000b />
+<SpanNode name='child2' span_id='0000000000000009' >
+  <SpanNode name='grandchild3' span_id='000000000000000b' />
 </SpanNode>\
 """)
     assert node.repr_xml(include_trace_id=True) == snapshot("""\
-<SpanNode name='child2' trace_id=00000000000000000000000000000001 >
-  <SpanNode name='grandchild3' trace_id=00000000000000000000000000000001 />
+<SpanNode name='child2' trace_id='00000000000000000000000000000001' >
+  <SpanNode name='grandchild3' trace_id='00000000000000000000000000000001' />
 </SpanNode>\
 """)
     assert node.repr_xml(include_start_timestamp=True) == snapshot("""\
@@ -383,6 +383,17 @@ async def test_span_tree_ancestors_methods():
     assert not leaf_node.matches({'no_ancestor_has': {'name_matches_regex': 'root'}})
     assert leaf_node.matches({'no_ancestor_has': {'name_matches_regex': 'abc'}})
 
+    # Test stop_recursing_when:
+    assert not leaf_node.matches(
+        {'some_ancestor_has': {'name_equals': 'level1'}, 'stop_recursing_when': {'name_equals': 'level2'}}
+    )
+    assert leaf_node.matches(
+        {'all_ancestors_have': {'name_matches_regex': 'level'}, 'stop_recursing_when': {'name_equals': 'level1'}}
+    )
+    assert leaf_node.matches(
+        {'no_ancestor_has': {'name_matches_regex': 'root'}, 'stop_recursing_when': {'name_equals': 'level1'}}
+    )
+
 
 async def test_span_tree_descendants_methods():
     """Test the descendant traversal methods in SpanNode."""
@@ -462,6 +473,17 @@ async def test_span_tree_descendants_methods():
     assert leaf_node.matches(negated_descendant_query)
     assert leaf_node.matches({'no_descendant_has': {'has_attributes': {'depth': 4}}})
 
+    # Test stop_recursing_when:
+    assert not root_node.matches(
+        {'some_descendant_has': {'name_equals': 'leaf'}, 'stop_recursing_when': {'name_equals': 'level2'}}
+    )
+    assert root_node.matches(
+        {'all_descendants_have': {'has_attribute_keys': ['depth']}, 'stop_recursing_when': {'name_equals': 'level2'}}
+    )
+    assert root_node.matches(
+        {'no_descendant_has': {'name_equals': 'leaf'}, 'stop_recursing_when': {'name_equals': 'level3'}}
+    )
+
 
 async def test_log_levels_and_exceptions():
     """Test recording different log levels and exceptions in spans."""

pydantic_ai-0.0.49/tests/models/cassettes/test_anthropic/test_document_url_input.yaml

@@ -0,0 +1,63 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '267'
+      content-type:
+      - application/json
+      host:
+      - api.anthropic.com
+    method: POST
+    parsed_body:
+      max_tokens: 1024
+      messages:
+      - content:
+        - text: What is the main content on this document?
+          type: text
+        - source:
+            type: url
+            url: https://pdfobject.com/pdf/sample.pdf
+          type: document
+        role: user
+      model: claude-3-5-sonnet-latest
+      stream: false
+    uri: https://api.anthropic.com/v1/messages
+  response:
+    headers:
+      connection:
+      - keep-alive
+      content-length:
+      - '795'
+      content-type:
+      - application/json
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      content:
+      - text: This document appears to be a sample PDF file that primarily contains Lorem ipsum text, which is placeholder
+          text commonly used in design and publishing. The document begins with "Sample PDF" and states "This is a simple
+          PDF file. Fun fun fun." followed by several paragraphs of Lorem ipsum text. The content doesn't convey any meaningful
+          information as Lorem ipsum is essentially dummy text used to demonstrate the visual form of a document without the
+          distraction of meaningful content.
+        type: text
+      id: msg_0146LphUoRKNWvDULHuTfu4H
+      model: claude-3-5-sonnet-20241022
+      role: assistant
+      stop_reason: end_turn
+      stop_sequence: null
+      type: message
+      usage:
+        cache_creation_input_tokens: 0
+        cache_read_input_tokens: 0
+        input_tokens: 2682
+        output_tokens: 96
+    status:
+      code: 200
+      message: OK
+version: 1

pydantic_ai-0.0.49/tests/models/cassettes/test_anthropic/test_image_url_input.yaml

@@ -0,0 +1,62 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '296'
+      content-type:
+      - application/json
+      host:
+      - api.anthropic.com
+    method: POST
+    parsed_body:
+      max_tokens: 1024
+      messages:
+      - content:
+        - text: What is this vegetable?
+          type: text
+        - source:
+            type: url
+            url: https://t3.ftcdn.net/jpg/00/85/79/92/360_F_85799278_0BBGV9OAdQDTLnKwAPBCcg1J7QtiieJY.jpg
+          type: image
+        role: user
+      model: claude-3-5-haiku-latest
+      stream: false
+    uri: https://api.anthropic.com/v1/messages
+  response:
+    headers:
+      connection:
+      - keep-alive
+      content-length:
+      - '660'
+      content-type:
+      - application/json
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      content:
+      - text: This is a potato. It's a yellow-brown, oblong-shaped potato with a smooth skin and some small eyes or blemishes
+          visible on its surface. Potatoes are starchy root vegetables that are a staple food in many cuisines around the
+          world. They can be prepared in numerous ways, such as boiling, baking, frying, or mashing, and are rich in carbohydrates
+          and nutrients.
+        type: text
+      id: msg_01WCNHqrhEGCXhoC4G1ojDHN
+      model: claude-3-5-haiku-20241022
+      role: assistant
+      stop_reason: end_turn
+      stop_sequence: null
+      type: message
+      usage:
+        cache_creation_input_tokens: 0
+        cache_read_input_tokens: 0
+        input_tokens: 296
+        output_tokens: 93
+    status:
+      code: 200
+      message: OK
+version: 1

pydantic_ai-0.0.49/tests/models/cassettes/test_openai_responses/test_openai_responses_model_builtin_tools.yaml

@@ -0,0 +1,120 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '217'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+    method: POST
+    parsed_body:
+      input:
+      - content: Give me the best news about LLMs from the last 24 hours. Be short.
+        role: user
+      instructions: ''
+      model: gpt-4o
+      stream: false
+      tool_choice: auto
+      tools:
+      - type: web_search_preview
+    uri: https://api.openai.com/v1/responses
+  response:
+    headers:
+      alt-svc:
+      - h3=":443"; ma=86400
+      connection:
+      - keep-alive
+      content-length:
+      - '3210'
+      content-type:
+      - application/json
+      openai-organization:
+      - pydantic-28gund
+      openai-processing-ms:
+      - '2843'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      created_at: 1743506361
+      error: null
+      id: resp_67ebcbb93728819197f923ff16e98bce04f5055a2a33abc3
+      incomplete_details: null
+      instructions: ''
+      max_output_tokens: null
+      metadata: {}
+      model: gpt-4o-2024-08-06
+      object: response
+      output:
+      - id: ws_67ebcbb9ab4481918bebf63b66dbb67c04f5055a2a33abc3
+        status: completed
+        type: web_search_call
+      - content:
+        - annotations:
+          - end_index: 571
+            start_index: 404
+            title: OpenAI plans to release open-weight language model in coming months
+            type: url_citation
+            url: https://www.reuters.com/technology/artificial-intelligence/openai-plans-release-open-weight-language-model-coming-months-2025-03-31/?utm_source=openai
+          - end_index: 846
+            start_index: 625
+            title: OpenAI plans to release open-weight language model in coming months
+            type: url_citation
+            url: https://www.reuters.com/technology/artificial-intelligence/openai-plans-release-open-weight-language-model-coming-months-2025-03-31/?utm_source=openai
+          text: "In the past 24 hours, OpenAI announced plans to release its first open-weight language model with reasoning
+            capabilities since GPT-2. This model will allow developers to fine-tune it for specific applications without needing
+            the original training data. To gather feedback and refine the model, OpenAI will host developer events starting
+            in San Francisco and expanding to Europe and Asia-Pacific regions. ([reuters.com](https://www.reuters.com/technology/artificial-intelligence/openai-plans-release-open-weight-language-model-coming-months-2025-03-31/?utm_source=openai))\n\n\n##
+            OpenAI to Release Open-Weight Language Model:\n- [OpenAI plans to release open-weight language model in coming
+            months](https://www.reuters.com/technology/artificial-intelligence/openai-plans-release-open-weight-language-model-coming-months-2025-03-31/?utm_source=openai) "
+          type: output_text
+        id: msg_67ebcbbaf988819192d44919020b82e704f5055a2a33abc3
+        role: assistant
+        status: completed
+        type: message
+      parallel_tool_calls: true
+      previous_response_id: null
+      reasoning:
+        effort: null
+        generate_summary: null
+      status: completed
+      store: true
+      temperature: 1.0
+      text:
+        format:
+          type: text
+      tool_choice: auto
+      tools:
+      - search_context_size: medium
+        type: web_search_preview
+        user_location:
+          city: null
+          country: US
+          region: null
+          timezone: null
+          type: approximate
+      top_p: 1.0
+      truncation: disabled
+      usage:
+        input_tokens: 320
+        input_tokens_details:
+          cached_tokens: 0
+        output_tokens: 200
+        output_tokens_details:
+          reasoning_tokens: 0
+        total_tokens: 520
+      user: null
+    status:
+      code: 200
+      message: OK
+version: 1

pydantic_ai-0.0.49/tests/models/cassettes/test_openai_responses/test_openai_responses_reasoning_generate_summary.yaml

@@ -0,0 +1,105 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '218'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+    method: POST
+    parsed_body:
+      input:
+      - content: What should I do to cross the street?
+        role: user
+      instructions: ''
+      model: computer-use-preview
+      reasoning:
+        effort: null
+        generate_summary: concise
+      stream: false
+      truncation: auto
+    uri: https://api.openai.com/v1/responses
+  response:
+    headers:
+      alt-svc:
+      - h3=":443"; ma=86400
+      connection:
+      - keep-alive
+      content-length:
+      - '1976'
+      content-type:
+      - application/json
+      openai-organization:
+      - pydantic-28gund
+      openai-processing-ms:
+      - '2793'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      created_at: 1743514924
+      error: null
+      id: resp_67ebed2c92cc81919d2fe37992a6a78b0e0766e7260ad9b9
+      incomplete_details: null
+      instructions: ''
+      max_output_tokens: null
+      metadata: {}
+      model: computer-use-preview-2025-03-11
+      object: response
+      output:
+      - content:
+        - annotations: []
+          text: |-
+            To cross the street safely, follow these steps:
+
+            1. **Use a Crosswalk**: Always use a designated crosswalk or pedestrian crossing whenever available.
+            2. **Press the Button**: If there is a pedestrian signal button, press it and wait for the signal.
+            3. **Look Both Ways**: Look left, right, and left again before stepping off the curb.
+            4. **Wait for the Signal**: Cross only when the pedestrian signal indicates it is safe to do so or when there is a clear gap in traffic.
+            5. **Stay Alert**: Be mindful of turning vehicles and stay attentive while crossing.
+            6. **Walk, Don't Run**: Walk across the street; running can increase the risk of falling or not noticing an oncoming vehicle.
+
+            Always follow local traffic rules and be cautious, even when crossing at a crosswalk. Safety is the priority.
+          type: output_text
+        id: msg_67ebed2db814819195e77f3dd1f057640e0766e7260ad9b9
+        role: assistant
+        status: completed
+        type: message
+      parallel_tool_calls: true
+      previous_response_id: null
+      reasoning:
+        effort: medium
+        generate_summary: concise
+      status: completed
+      store: true
+      temperature: 1.0
+      text:
+        format:
+          type: text
+      tool_choice: auto
+      tools: []
+      top_p: 1.0
+      truncation: auto
+      usage:
+        input_tokens: 15
+        input_tokens_details:
+          cached_tokens: 0
+        output_tokens: 180
+        output_tokens_details:
+          reasoning_tokens: 0
+        total_tokens: 195
+      user: null
+    status:
+      code: 200
+      message: OK
+version: 1

{pydantic_ai-0.0.48 → pydantic_ai-0.0.49}/tests/models/test_anthropic.py

@@ -566,11 +566,9 @@ async def test_image_url_input(allow_model_requests: None, anthropic_api_key: st
             ImageUrl(url='https://t3.ftcdn.net/jpg/00/85/79/92/360_F_85799278_0BBGV9OAdQDTLnKwAPBCcg1J7QtiieJY.jpg'),
         ]
     )
-    assert result.data == snapshot("""\
-This is a potato. It's a yellow-skinned potato with a somewhat oblong or oval shape. The surface is covered in small eyes or dimples, which is typical of potato skin. The color is a golden-yellow, and the potato appears to be clean and fresh, photographed against a white background.
-
-Potatoes are root vegetables that are staple foods in many cuisines around the world. They can be prepared in numerous ways such as boiling, baking, roasting, frying, or mashing. This particular potato looks like it could be a Yukon Gold or a similar yellow-fleshed variety.\
-""")
+    assert result.data == snapshot(
+        "This is a potato. It's a yellow-brown, oblong-shaped potato with a smooth skin and some small eyes or blemishes visible on its surface. Potatoes are starchy root vegetables that are a staple food in many cuisines around the world. They can be prepared in numerous ways, such as boiling, baking, frying, or mashing, and are rich in carbohydrates and nutrients."
+    )
 
 
 @pytest.mark.vcr()
@@ -639,11 +637,11 @@ async def test_document_url_input(allow_model_requests: None, anthropic_api_key:
     m = AnthropicModel('claude-3-5-sonnet-latest', provider=AnthropicProvider(api_key=anthropic_api_key))
     agent = Agent(m)
 
-    document_url = DocumentUrl(url='https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf')
+    document_url = DocumentUrl(url='https://pdfobject.com/pdf/sample.pdf')
 
     result = await agent.run(['What is the main content on this document?', document_url])
     assert result.data == snapshot(
-        'The document appears to be a simple PDF file with only the text "Dummy PDF file" displayed at the top. It seems to be a blank or template document with minimal content.'
+        'This document appears to be a sample PDF file that primarily contains Lorem ipsum text, which is placeholder text commonly used in design and publishing. The document begins with "Sample PDF" and states "This is a simple PDF file. Fun fun fun." followed by several paragraphs of Lorem ipsum text. The content doesn\'t convey any meaningful information as Lorem ipsum is essentially dummy text used to demonstrate the visual form of a document without the distraction of meaningful content.'
     )
 
 

{pydantic_ai-0.0.48 → pydantic_ai-0.0.49}/tests/models/test_openai_responses.py

@@ -22,7 +22,7 @@ from pydantic_ai.messages import (
 from ..conftest import IsDatetime, IsStr, TestEnv, try_import
 
 with try_import() as imports_successful:
-    from pydantic_ai.models.openai import OpenAIModelSettings, OpenAIResponsesModel
+    from pydantic_ai.models.openai import OpenAIModelSettings, OpenAIResponsesModel, OpenAIResponsesModelSettings
     from pydantic_ai.providers.openai import OpenAIProvider
 
 pytestmark = [
@@ -118,6 +118,30 @@ async def test_openai_responses_reasoning_effort(allow_model_requests: None, ope
     )
 
 
+async def test_openai_responses_reasoning_generate_summary(allow_model_requests: None, openai_api_key: str):
+    model = OpenAIResponsesModel('computer-use-preview', provider=OpenAIProvider(api_key=openai_api_key))
+    agent = Agent(
+        model=model,
+        model_settings=OpenAIResponsesModelSettings(
+            openai_reasoning_generate_summary='concise',
+            openai_truncation='auto',
+        ),
+    )
+    result = await agent.run('What should I do to cross the street?')
+    assert result.data == snapshot("""\
+To cross the street safely, follow these steps:
+
+1. **Use a Crosswalk**: Always use a designated crosswalk or pedestrian crossing whenever available.
+2. **Press the Button**: If there is a pedestrian signal button, press it and wait for the signal.
+3. **Look Both Ways**: Look left, right, and left again before stepping off the curb.
+4. **Wait for the Signal**: Cross only when the pedestrian signal indicates it is safe to do so or when there is a clear gap in traffic.
+5. **Stay Alert**: Be mindful of turning vehicles and stay attentive while crossing.
+6. **Walk, Don't Run**: Walk across the street; running can increase the risk of falling or not noticing an oncoming vehicle.
+
+Always follow local traffic rules and be cautious, even when crossing at a crosswalk. Safety is the priority.\
+""")
+
+
 async def test_openai_responses_system_prompt(allow_model_requests: None, openai_api_key: str):
     model = OpenAIResponsesModel('gpt-4o', provider=OpenAIProvider(api_key=openai_api_key))
     agent = Agent(model=model, system_prompt='You are a helpful assistant.')
@@ -286,3 +310,39 @@ async def test_openai_responses_model_http_error(allow_model_requests: None, ope
     with pytest.raises(ModelHTTPError):
         async with agent.run_stream('What is the capital of France?'):
             ...
+
+
+async def test_openai_responses_model_builtin_tools(allow_model_requests: None, openai_api_key: str):
+    model = OpenAIResponsesModel('gpt-4o', provider=OpenAIProvider(api_key=openai_api_key))
+    settings = OpenAIResponsesModelSettings(openai_builtin_tools=[{'type': 'web_search_preview'}])
+    agent = Agent(model=model, model_settings=settings)
+    result = await agent.run('Give me the best news about LLMs from the last 24 hours. Be short.')
+
+    # NOTE: We don't have the tool call because OpenAI calls the tool internally.
+    assert result.all_messages() == snapshot(
+        [
+            ModelRequest(
+                parts=[
+                    UserPromptPart(
+                        content='Give me the best news about LLMs from the last 24 hours. Be short.',
+                        timestamp=IsDatetime(),
+                    )
+                ]
+            ),
+            ModelResponse(
+                parts=[
+                    TextPart(
+                        content="""\
+In the past 24 hours, OpenAI announced plans to release its first open-weight language model with reasoning capabilities since GPT-2. This model will allow developers to fine-tune it for specific applications without needing the original training data. To gather feedback and refine the model, OpenAI will host developer events starting in San Francisco and expanding to Europe and Asia-Pacific regions. ([reuters.com](https://www.reuters.com/technology/artificial-intelligence/openai-plans-release-open-weight-language-model-coming-months-2025-03-31/?utm_source=openai))
+
+
+## OpenAI to Release Open-Weight Language Model:
+- [OpenAI plans to release open-weight language model in coming months](https://www.reuters.com/technology/artificial-intelligence/openai-plans-release-open-weight-language-model-coming-months-2025-03-31/?utm_source=openai) \
+"""
+                    )
+                ],
+                model_name='gpt-4o-2024-08-06',
+                timestamp=IsDatetime(),
+            ),
+        ]
+    )