GitHubProvider streamed response lacks timestamp

[mamazinho]

Initial Checks

• I confirm that I'm using the latest version of Pydantic AI
• I confirm that I searched for my issue in https://github.com/pydantic/pydantic-ai/issues before opening this issue

Description

I am trying to use the GitHubProvider with OpenAIChatModel in one of my applications and reproducing the documentation usage.
However, there is a difference between using the GitHubProvider and OpenAIProvider. GitHubProvider doesn't handle the usage information and the timestamp data so well.

I changed my app to use OpenAIProvider and the response was as expected (with timestamp and usage data).

I am printing the result.all_messages_json() and result.timestamp() at the end of the stream code and the print is very different using githubProvider and openAIProvider. The main point that makes a huge difference in my app is about the timestamp in the model response, I need this timestamp to control the order of messages.

As well, I will leave the code below with the option to switch between providers. Despite I am printing only all_messages_json() method, the problem also happens in new_messages() method

OpenAIProvider output

ALL MESSAGES:  b'[{"parts":[{"content":"Me diga apenas um nome brasileiro","timestamp":"2025-09-24T15:42:11.449728Z","part_kind":"user-prompt"}],"instructions":null,"kind":"request"},{"parts":[{"content":"Maria","id":null,"part_kind":"text"}],"usage":{"input_tokens":13,"cache_write_tokens":0,"cache_read_tokens":0,"output_tokens":1,"input_audio_tokens":0,"cache_audio_read_tokens":0,"output_audio_tokens":0,"details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0}},"model_name":"gpt-4o-2024-08-06","timestamp":"2025-09-24T15:42:15Z","kind":"response","provider_name":"openai","provider_details":{"finish_reason":"stop"},"provider_response_id":"chatcmpl-CJLvDzQiCRHEEfWMjH8OKRJjtTggT","finish_reason":"stop"}]'
TIMESTAMP:  2025-09-24 15:42:15+00:00

GitHubProvider output

ALL MESSAGES:  b'[{"parts":[{"content":"Me diga apenas um nome brasileiro","timestamp":"2025-09-24T15:45:47.259848Z","part_kind":"user-prompt"}],"instructions":null,"kind":"request"},{"parts":[{"content":"Clarice Lispector","id":null,"part_kind":"text"}],"usage":{"input_tokens":13,"cache_write_tokens":0,"cache_read_tokens":0,"output_tokens":5,"input_audio_tokens":0,"cache_audio_read_tokens":0,"output_audio_tokens":0,"details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0}},"model_name":"gpt-4o-2024-11-20","timestamp":"1970-01-01T00:00:00Z","kind":"response","provider_name":"github","provider_details":{"finish_reason":"stop"},"provider_response_id":"chatcmpl-CJLyeUMNKA83PjvLiTggPjBChHU3F","finish_reason":"stop"}]'
TIMESTAMP:  1970-01-01 00:00:00+00:00

Example Code

from datetime import datetime, timezone
from typing import Any, AsyncGenerator, Annotated

from fastapi import Form
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from pydantic_ai import Agent, UnexpectedModelBehavior
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.github import GitHubProvider
from pydantic_ai.providers.openai import OpenAIProvider
from pydantic_ai.messages import (
    ModelMessage,
    ModelRequest,
    ModelResponse,
    TextPart,
    UserPromptPart,
)

from datalab_api.apps.chats.choices import Sender
from datalab_api.config.settings import settings

model = OpenAIChatModel(model_name="gpt-4o", provider=OpenAIProvider(api_key=settings.openai_api_token_ai))
# model = OpenAIChatModel(model_name="gpt-4o", provider=GitHubProvider(api_key=settings.github_api_token_ai))
agent = Agent(model)


class ModelChatResponse(BaseModel):
    role: str
    timestamp: str
    content: str

    def formatted_json(self) -> str:
        return self.model_dump_json().encode("utf-8") + b"\n"
    
    @classmethod
    def from_model_message(cls, m: ModelMessage):
        first_part = m.parts[0]
        if isinstance(m, ModelRequest):
            if isinstance(first_part, UserPromptPart):
                assert isinstance(first_part.content, str)
                return ModelChatResponse(
                    role="user",
                    timestamp=first_part.timestamp.isoformat(),
                    content=first_part.content,
                )
        elif isinstance(m, ModelResponse):
            if isinstance(first_part, TextPart):
                return ModelChatResponse(
                    role="agent",
                    timestamp=m.timestamp.isoformat(),
                    content=first_part.content,
                )
        raise UnexpectedModelBehavior(f'Unexpected message type for chat app: {m}')

class ChatService:    
    async def stream_messages(self, chat_id: int, prompt: str) -> AsyncGenerator[Any, Any]:
        yield ModelChatResponse(
            role="user",
            timestamp=datetime.now(tz=timezone.utc).isoformat(),
            content=prompt,
        ).formatted_json()

        async with agent.run_stream(prompt) as result:
            async for text in result.stream_text():
                m = ModelResponse(parts=[TextPart(text)], timestamp=result.timestamp())
                yield ModelChatResponse.from_model_message(m).formatted_json()
        
        print("ALL MESSAGES: ", result.all_messages_json())
        print("TIMESTAMP: ", result.timestamp())


@chat_router.post("/{chat_id}/messages/")
async def post_chat(chat_id: int, prompt: Annotated[str, Form()]) -> StreamingResponse:
    return StreamingResponse(ChatService().stream_messages(chat_id, prompt), media_type="text/plain")

Python, Pydantic AI & LLM client version

Python: 3.13
Pydantic: 1.0.10
LLM Model: gpt-4o
Provider: GithubProvider
ChatModel: OpenAI

[DouweM]

@mamazinho Can you use https://ai.pydantic.dev/logfire with logfire.instrument_httpx(capture_all=True) and share the HTTP response from GitHub? I'm curious if the timestamp and usage details are not in there at all, or if they're formatted differently.

[mamazinho]

Hey @DouweM. I set the logfire on project and see the log and will share the response log below: (spoiler: It seems that github doesn't send the timestamp)

Response

{
  "gen_ai.input.messages": [
    {
      "role": "user",
      "parts": [
        {
          "type": "text",
          "content": "Me diga apenas um nome brasileiro"
        }
      ]
    }
  ],
  "gen_ai.operation.name": "chat",
  "gen_ai.output.messages": [
    {
      "role": "assistant",
      "parts": [
        {
          "type": "text",
          "content": "João."
        }
      ],
      "finish_reason": "stop"
    }
  ],
  "gen_ai.request.model": "gpt-4o",
  "gen_ai.response.finish_reasons": [
    "stop"
  ],
  "gen_ai.response.id": "chatcmpl-COBwGnWqAD8GqthA3Rb06S0mcTABi",
  "gen_ai.response.model": "gpt-4o-2024-11-20",
  "gen_ai.system": "github",
  "gen_ai.usage.input_tokens": 13,
  "gen_ai.usage.output_tokens": 4,
  "model_request_parameters": {
    "function_tools": [],
    "builtin_tools": [],
    "output_mode": "text",
    "output_object": null,
    "output_tools": [],
    "allow_text_output": true
  },
  "server.address": "models.github.ai"
}

[mamazinho]

But, looking the same log using the openAI, we have the same behavior, the timestamp doesn't appear

Logs

{
  "gen_ai.input.messages": [
    {
      "role": "user",
      "parts": [
        {
          "type": "text",
          "content": "Me diga apenas um nome brasileiro"
        }
      ]
    },
    {
      "role": "assistant",
      "parts": [
        {
          "type": "text",
          "content": "João."
        }
      ]
    },
    {
      "role": "user",
      "parts": [
        {
          "type": "text",
          "content": "Me diga apenas um nome brasileiro"
        }
      ]
    }
  ],
  "gen_ai.operation.name": "chat",
  "gen_ai.output.messages": [
    {
      "role": "assistant",
      "parts": [
        {
          "type": "text",
          "content": "Lucas."
        }
      ],
      "finish_reason": "stop"
    }
  ],
  "gen_ai.request.model": "gpt-4o",
  "gen_ai.response.finish_reasons": [
    "stop"
  ],
  "gen_ai.response.id": "chatcmpl-COCCbiAG1Idmm6Ygz6ZqX5gLNPfvS",
  "gen_ai.response.model": "gpt-4o-2024-08-06",
  "gen_ai.system": "openai",
  "gen_ai.usage.input_tokens": 30,
  "gen_ai.usage.output_tokens": 2,
  "model_request_parameters": {
    "function_tools": [],
    "builtin_tools": [],
    "output_mode": "text",
    "output_object": null,
    "output_tools": [],
    "allow_text_output": true
  },
  "operation.cost": 0.000095,
  "server.address": "api.openai.com"
}

[DouweM]

@mamazinho Those are the attributes for the chat span, right? Can you look at the HTTP request span that should be nested under it if you use logfire.instrument_httpx(capture_all=True)? It should also have a response data span under it. That's the raw response from the API that I'm curious about.

[mamazinho]

@DouweM Right, but even looking the HTTP request span, I can't see the response data anywhere

Github

Open AI

[mamazinho]

Another point about dates, using the OpenAI provider, still have a problem with timestamp that comes without milliseconds. The OpenAI provider only comes with the seconds and the API itself returns only a timestamp with this precision. There is a recommended way to "adjust this" and override the timestamp in the result? To put a datetime with seconds?

[mamazinho]

I made the same request manually on postman to github, and github sends the same field of openAI, a created in epoch timestamp

[mamazinho]

Then, It seems that the github issue is a problem in pydantic-ai, I update my local version to 1.0.17 and the problem still happens. And both, Github and OpenAI, have this problem of not returning the millisecond precision, so, when the server response is very fast, sometimes the prompt I sent gets an early timestamp than the AI answer

[DouweM]

@mamazinho Since GitHub is sending the created field like OpenAI is, I'd expect it to end up the same on ModelResponse.timestamp(). In your example code where it's apparently coming in as unix timestamp 0, I notice you're using streaming. Is it possible that the streaming responses don't include the created timestamp, or not on the first chunk? You can likely find out with some print-based debugging here:

pydantic-ai/pydantic_ai_slim/pydantic_ai/models/openai.py

Line 629 in 6cf43ea

_timestamp=number_to_datetime(first_chunk.created),

If a later chunk does have the timestamp, we could use that.

---

The lack of millisecond precision is annoying. If you want to insert your own more precise timestamps, I recommend subclassing OpenAIChatModel and overriding the _process_response and _process_streamed_response methods.

---

Also, can you clarify the issue you're seeing with usage?

[mamazinho]

@DouweM Thank you! I override the methods you told me and it works very well using both providers!

Code

class OpenAIChatModelAdapter(OpenAIChatModel):
    """Adapter for OpenAIChatModel to override datetime and use a milliseconds precision such as in github provider as openai."""
    
    @override
    def _process_response(self, response: ChatCompletion | str) -> ModelResponse:
        response.created = None
        return super()._process_response(response)
    
    @override
    async def _process_streamed_response(
        self, response: AsyncStream[ChatCompletionChunk], model_request_parameters: ModelRequestParameters
    ) -> OpenAIStreamedResponse:
        
        response = await super()._process_streamed_response(response, model_request_parameters)
        response._timestamp = datetime.now(tz=timezone.utc)
        return response

Maybe we can close this issue and this part of code may help someone else who passes through this as well. I don't know if I see something that can change in pydantic-ai clearly, maybe just a fallback in this methods like: if not response.created: mestamp = datetime.now().

[DouweM]

@mamazinho We already have logic like that for non-streaming responses:

pydantic-ai/pydantic_ai_slim/pydantic_ai/models/openai.py

Lines 526 to 530 in 013c43b

	if response.created:
	timestamp = number_to_datetime(response.created)
	else:
	timestamp = _now_utc()
	response.created = int(timestamp.timestamp())

. It makes sense to do it in _process_streamed_response as well, if you want to submit a PR!