Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

3.0 KB
Raw Blame
import json
from typing import cast

from posthog.schema import AssistantEventType, AssistantGenerationStatusEvent, AssistantUpdateEvent, SubagentUpdateEvent

from posthog.sync import database_sync_to_async

from products.posthog_ai.backend.models.assistant import Conversation

from ee.hogai.api.serializers import ConversationMinimalSerializer
from ee.hogai.utils.types import AssistantMessageUnion, AssistantOutput
from ee.hogai.utils.types.base import ApprovalPayload


class AssistantSSESerializer:
    async def dumps(self, event: AssistantOutput) -> str:
        event_type, event_data = event
        if event_type == AssistantEventType.MESSAGE:
            return self._serialize_message(cast(AssistantMessageUnion, event_data))
        elif event_type == AssistantEventType.CONVERSATION:
            return await self._serialize_conversation(cast(Conversation, event_data))
        elif event_type == AssistantEventType.STATUS:
            return self._serialize_status(cast(AssistantGenerationStatusEvent, event_data))
        elif event_type == AssistantEventType.UPDATE:
            return self._serialize_update(cast(AssistantUpdateEvent | SubagentUpdateEvent, event_data))
        elif event_type == AssistantEventType.APPROVAL:
            return self._serialize_approval(cast(ApprovalPayload, event_data))
        else:
            raise ValueError(f"Unknown event type: {event_type}")

    def _serialize_message(self, message: AssistantMessageUnion) -> str:
        output = f"event: {AssistantEventType.MESSAGE}\n"
        output += f"data: {message.model_dump_json(exclude_none=True)}\n\n"
        return output

    def _serialize_status(self, status: AssistantGenerationStatusEvent) -> str:
        output = f"event: {AssistantEventType.STATUS}\n"
        output += f"data: {status.model_dump_json(exclude_none=True)}\n\n"
        return output

    def _serialize_update(self, update: AssistantUpdateEvent | SubagentUpdateEvent) -> str:
        output = f"event: {AssistantEventType.UPDATE}\n"
        output += f"data: {update.model_dump_json(exclude_none=True)}\n\n"
        return output

    def _serialize_approval(self, approval: ApprovalPayload) -> str:
        output = f"event: {AssistantEventType.APPROVAL}\n"
        output += f"data: {approval.model_dump_json(exclude_none=True)}\n\n"
        return output

    # `_serialize_conversation` needs to be async, as some serialization CAN involve sneaky sync ORM queries. We can't guarantee it won't.
    # In particular, serialization Conversation can involve fetching conversation.user from DB sync. This shouldn't
    # be needed, because we SHOULD be doing Conversation.objects.select_related("user"), but async here is a cheap way to safe.
    @database_sync_to_async
    def _serialize_conversation(self, conversation: Conversation) -> str:
        output = f"event: {AssistantEventType.CONVERSATION}\n"
        json_conversation = json.dumps(ConversationMinimalSerializer(conversation).data)
        output += f"data: {json_conversation}\n\n"
        return output