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.

7.7 KB
Raw Blame
from collections.abc import AsyncGenerator
from typing import TYPE_CHECKING, Any, Optional
from uuid import UUID

import posthoganalytics
from opentelemetry import trace

from posthog.schema import AgentMode, AssistantMessage, HumanMessage, MaxBillingContext

from posthog import event_usage
from posthog.models import Team, User
from posthog.sync import database_sync_to_async

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

from ee.hogai.chat_agent import AssistantGraph
from ee.hogai.chat_agent.stream_processor import ChatAgentStreamProcessor
from ee.hogai.chat_agent.taxonomy.types import TaxonomyNodeName
from ee.hogai.core.runner import BaseAgentRunner
from ee.hogai.utils.types import AssistantNodeName, AssistantOutput, AssistantState, PartialAssistantState

_tracer = trace.get_tracer(__name__)

if TYPE_CHECKING:
    from products.slack_app.backend.slack_thread import SlackThreadContext

    from ee.hogai.utils.types.composed import MaxNodeName


STREAMING_NODES: set["MaxNodeName"] = {
    AssistantNodeName.ROOT,
    AssistantNodeName.INKEEP_DOCS,
    AssistantNodeName.MEMORY_ONBOARDING,
    AssistantNodeName.MEMORY_INITIALIZER,
    AssistantNodeName.MEMORY_ONBOARDING_ENQUIRY,
    AssistantNodeName.MEMORY_ONBOARDING_FINALIZE,
    AssistantNodeName.DASHBOARD_CREATION,
}


VERBOSE_NODES: set["MaxNodeName"] = {
    AssistantNodeName.TRENDS_GENERATOR,
    AssistantNodeName.FUNNEL_GENERATOR,
    AssistantNodeName.RETENTION_GENERATOR,
    AssistantNodeName.SQL_GENERATOR,
    AssistantNodeName.INSIGHTS_SEARCH,
    AssistantNodeName.QUERY_EXECUTOR,
    AssistantNodeName.MEMORY_INITIALIZER_INTERRUPT,
    AssistantNodeName.ROOT,
    AssistantNodeName.ROOT_TOOLS,
    AssistantNodeName.SLASH_COMMAND_HANDLER,
    TaxonomyNodeName.TOOLS_NODE,
    TaxonomyNodeName.TASK_EXECUTOR,
}


class ChatAgentRunner(BaseAgentRunner):
    _state: Optional[AssistantState]
    _initial_state: Optional[AssistantState | PartialAssistantState]
    _selected_agent_mode: AgentMode | None

    def __init__(
        self,
        team: Team,
        conversation: Conversation,
        *,
        new_message: Optional[HumanMessage] = None,
        user: User,
        session_id: Optional[str] = None,
        contextual_tools: Optional[dict[str, Any]] = None,
        is_new_conversation: bool = False,
        trace_id: Optional[str | UUID] = None,
        parent_span_id: Optional[str | UUID] = None,
        billing_context: Optional[MaxBillingContext] = None,
        initial_state: Optional[AssistantState | PartialAssistantState] = None,
        agent_mode: AgentMode | None = None,
        slack_thread_context: Optional["SlackThreadContext"] = None,
        use_checkpointer: bool = True,
        is_agent_billable: bool = True,
        is_impersonated: bool = False,
        resume_payload: Optional[dict[str, Any]] = None,
    ):
        super().__init__(
            team,
            conversation,
            new_message=new_message,
            user=user,
            graph_class=AssistantGraph,
            state_type=AssistantState,
            partial_state_type=PartialAssistantState,
            session_id=session_id,
            contextual_tools=contextual_tools,
            is_new_conversation=is_new_conversation,
            trace_id=trace_id,
            parent_span_id=parent_span_id,
            initial_state=initial_state,
            billing_context=billing_context,
            use_checkpointer=use_checkpointer,
            is_agent_billable=is_agent_billable,
            is_impersonated=is_impersonated,
            stream_processor=ChatAgentStreamProcessor(
                verbose_nodes=VERBOSE_NODES,
                streaming_nodes=STREAMING_NODES,
                state_type=AssistantState,
                team=team,
                user=user,
            ),
            slack_thread_context=slack_thread_context,
            resume_payload=resume_payload,
        )
        self._selected_agent_mode = agent_mode

    def get_initial_state(self) -> AssistantState:
        if self._latest_message:
            new_state = AssistantState(
                messages=[self._latest_message],
                start_id=self._latest_message.id,
                query_generation_retry_count=0,
                graph_status=None,
                rag_context=None,
            )
            # Only set the agent mode if it was explicitly set.
            if self._selected_agent_mode:
                if self._selected_agent_mode == AgentMode.PLAN:
                    new_state.supermode = AgentMode.PLAN
                    new_state.agent_mode = AgentMode.SQL
                else:
                    new_state.agent_mode = self._selected_agent_mode
            return new_state

        # When resuming, do not set the mode. It should start from the same mode as the previous generation.
        return AssistantState(messages=[])

    def get_resumed_state(self) -> PartialAssistantState:
        if not self._latest_message:
            new_state = PartialAssistantState(messages=[], graph_status="resumed", query_generation_retry_count=0)
            if self._selected_agent_mode:
                new_state.agent_mode = self._selected_agent_mode
            return new_state
        new_state = PartialAssistantState(
            messages=[self._latest_message], graph_status="resumed", query_generation_retry_count=0
        )
        if self._selected_agent_mode:
            new_state.agent_mode = self._selected_agent_mode
        return new_state

    async def astream(
        self,
        stream_message_chunks: bool = True,
        stream_subgraphs: bool = True,
        stream_first_message: bool = True,
        stream_only_assistant_messages: bool = False,
    ) -> AsyncGenerator[AssistantOutput]:
        if self._selected_agent_mode and self._user:
            with _tracer.start_as_current_span("posthoganalytics.capture"):
                await database_sync_to_async(posthoganalytics.capture)(
                    distinct_id=self._user.distinct_id,
                    event="ai mode executed",
                    properties={
                        "mode": self._selected_agent_mode,
                        "previous_mode": None,
                        "is_initial_mode": True,
                        "conversation_id": str(self._conversation.id),
                        "$session_id": self._session_id,
                    },
                    groups=event_usage.groups(team=self._team),
                    send_feature_flags=True,
                )

        last_ai_message: AssistantMessage | None = None
        async for stream_event in super().astream(
            stream_message_chunks, stream_subgraphs, stream_first_message, stream_only_assistant_messages
        ):
            _, message = stream_event
            if isinstance(message, AssistantMessage):
                last_ai_message = message
            yield stream_event

        if not self._use_checkpointer:
            # we don't want to track subagent conversations
            return

        output = last_ai_message.content if isinstance(last_ai_message, AssistantMessage) else None
        await self._report_conversation_state(
            "chat with ai",
            {
                "prompt": self._latest_message.content if self._latest_message else None,
                "output": output,
                "is_new_conversation": self._is_new_conversation,
                "slack_workspace_domain": self._conversation.slack_workspace_domain,
                "$session_id": self._session_id,
                "agent_mode": self._selected_agent_mode,
                # The sandbox runtime emits this same event when its run terminalizes. Without a
                # runtime tag the two halves of every series are indistinguishable.
                "agent_runtime": "langgraph",
            },
        )