: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
import uuid
from collections.abc import Sequence
from typing import cast
import structlog
from langchain_core.runnables import RunnableConfig
from langchain_openai import ChatOpenAI
from posthog.schema import AssistantToolCall, AssistantToolCallMessage, HumanMessage, TaskExecutionStatus
from posthog.exceptions_capture import capture_exception
from posthog.models.team.team import Team
from posthog.models.user import User
from ee.hogai.artifacts.utils import unwrap_visualization_artifact_content
from ee.hogai.chat_agent.insights.nodes import InsightSearchNode
from ee.hogai.chat_agent.parallel_task_execution.prompts import AGENT_TASK_PROMPT_TEMPLATE
from ee.hogai.context import AssistantContextManager
from ee.hogai.utils.dispatcher import AssistantDispatcher
from ee.hogai.utils.helpers import extract_stream_update
from ee.hogai.utils.state import is_value_update
from ee.hogai.utils.types import (
AnyAssistantGeneratedQuery,
AssistantMessageUnion,
AssistantState,
InsightArtifact,
PartialAssistantState,
TaskArtifact,
TaskResult,
)
logger = structlog.get_logger(__name__)
class WithInsightCreationTaskExecution:
_team: Team
_user: User
_parent_tool_call_id: str | None
_context_manager: AssistantContextManager | None
@property
def dispatcher(self) -> AssistantDispatcher:
raise NotImplementedError
async def _execute_create_insight(self, input_dict: dict) -> TaskResult | None:
"""Execute a single task using the full insights pipeline.
Always returns a TaskResult (even for failures), never None.
The type allows None for compatibility with the base class.
"""
# Import here to avoid circular dependency
from ee.hogai.chat_agent.insights_graph.graph import InsightsGraph
task = cast(AssistantToolCall, input_dict["task"])
artifacts = input_dict["artifacts"]
config = input_dict.get("config")
self._current_task_id = task.id
# This is needed by the InsightsGraph to return an AssistantToolCallMessage
task_tool_call_id = f"task_{uuid.uuid4().hex[:8]}"
query = task.args["query_description"]
formatted_instructions = AGENT_TASK_PROMPT_TEMPLATE.format(
task_prompt=query,
)
human_message = HumanMessage(content=formatted_instructions, id=str(uuid.uuid4()))
input_state = AssistantState(
messages=[human_message],
start_id=human_message.id,
root_tool_call_id=task_tool_call_id,
root_tool_insight_plan=query,
)
subgraph_result_messages: list[AssistantMessageUnion] = []
assistant_graph = InsightsGraph(self._team, self._user).compile_full_graph()
try:
async for chunk in assistant_graph.astream(
input_state,
config,
subgraphs=True,
stream_mode=["updates"],
):
if not chunk:
continue
update = extract_stream_update(chunk)
if is_value_update(update):
_, content = update
node_name = next(iter(content.keys()))
messages = content[node_name]["messages"]
subgraph_result_messages.extend(messages)
for message in messages:
self.dispatcher.message(message)
except Exception as e:
capture_exception(e)
raise
if len(subgraph_result_messages) == 0 or not subgraph_result_messages[-1]:
logger.warning("Task failed: no messages received from insights subgraph", task_id=task.id)
return TaskResult(
id=task.id,
result="",
artifacts=[],
status=TaskExecutionStatus.FAILED,
)
last_message = subgraph_result_messages[-1]
if not isinstance(last_message, AssistantToolCallMessage):
logger.warning(
"Task failed: last message is not AssistantToolCallMessage",
task_id=task.id,
)
return TaskResult(
id=task.id,
result="",
artifacts=[],
status=TaskExecutionStatus.FAILED,
)
response = last_message.content
artifacts = await self._extract_artifacts(subgraph_result_messages, task)
if len(artifacts) == 0:
response += "\n\nNo artifacts were generated."
logger.warning("Task failed: no artifacts extracted", task_id=task.id)
return TaskResult(
id=task.id,
result=response,
artifacts=[],
status=TaskExecutionStatus.FAILED,
)
return TaskResult(
id=task.id,
result=response,
artifacts=artifacts,
status=TaskExecutionStatus.COMPLETED,
)
async def _extract_artifacts(
self, subgraph_result_messages: list[AssistantMessageUnion], tool_call: AssistantToolCall
) -> Sequence[InsightArtifact]:
"""Extract artifacts from insights subgraph execution results."""
assert self._context_manager is not None
task_artifacts: list[InsightArtifact] = []
artifact_messages = await self._context_manager.artifacts.aenrich_messages(
subgraph_result_messages, artifacts_only=True
)
for artifact in artifact_messages:
visualization_content = unwrap_visualization_artifact_content(artifact)
if visualization_content is None:
continue
task_artifacts.append(
InsightArtifact(
task_id=tool_call.id,
id=artifact.id,
content=visualization_content.description or "No description provided",
query=cast(AnyAssistantGeneratedQuery, visualization_content.query),
)
)
return task_artifacts
def _get_model(self) -> ChatOpenAI:
return ChatOpenAI(
model="gpt-4.1",
temperature=0.3,
)
class WithInsightSearchTaskExecution:
_team: Team
_user: User
_parent_tool_call_id: str | None
@property
def dispatcher(self) -> AssistantDispatcher:
raise NotImplementedError
async def _execute_search_insights(self, input_dict: dict) -> TaskResult:
"""Execute a single task using a single node."""
task = cast(AssistantToolCall, input_dict["task"])
config = cast(RunnableConfig, input_dict.get("config", RunnableConfig()))
query = task.args["search_insights_query"]
task_tool_call_id = f"task_{uuid.uuid4().hex[:8]}"
input_state = AssistantState(
root_tool_call_id=task_tool_call_id,
search_insights_query=query,
)
try:
result = await InsightSearchNode(self._team, self._user).arun(input_state, config)
if not result or not result.messages:
logger.warning("Task failed: no messages received from node executor", task_id=task.id)
return TaskResult(
id=task.id,
result="",
artifacts=[],
status=TaskExecutionStatus.FAILED,
)
messages = list(result.messages)
task_result = messages[0].content if messages and isinstance(messages[0], AssistantToolCallMessage) else ""
# Extract artifacts from the result and messages
extracted_artifacts = self._extract_artifacts_from_messages(messages, result, task)
if len(extracted_artifacts) == 0:
logger.warning("Task failed: no artifacts extracted", task_id=task.id)
return TaskResult(
id=task.id,
result="No insights were found.",
artifacts=[],
status=TaskExecutionStatus.FAILED,
)
return TaskResult(
id=task.id,
result=task_result,
artifacts=extracted_artifacts,
status=TaskExecutionStatus.COMPLETED,
)
except Exception as e:
capture_exception(e)
logger.exception(f"Task failed with exception: {e}", task_id=task.id)
return TaskResult(
id=task.id,
result="",
artifacts=[],
status=TaskExecutionStatus.FAILED,
)
def _extract_artifacts_from_messages(
self, messages: list[AssistantMessageUnion], result: PartialAssistantState, tool_call: AssistantToolCall
) -> list[TaskArtifact]:
"""Extract artifacts from captured messages and node result."""
artifacts: list[TaskArtifact] = []
# Get content from messages (look for AssistantToolCallMessage)
content = ""
for msg in messages:
if isinstance(msg, AssistantToolCallMessage):
content = msg.content
break
# Create artifacts from selected insight IDs
if result.selected_insight_ids:
artifacts.extend(
[
TaskArtifact(
task_id=tool_call.id,
id=str(insight_id),
content=content,
)
for insight_id in result.selected_insight_ids
]
)
return artifacts