: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 type { BuiltLogic } from 'kea'
import {
AssistantMessage,
AssistantMessageType,
AssistantToolCallMessage,
RootAssistantMessage,
} from '~/queries/schema/schema-assistant-messages'
import { DataVisualizationNode, NodeKind } from '~/queries/schema/schema-general'
import { DashboardType, InsightShortId, InsightModel } from '~/types'
import { EnhancedToolCall } from './max-constants'
import { MaxContextItem, MaxContextType, MaxUIContext } from './maxTypes'
import {
activeSceneLogicHasMaxContext,
dashboardToMaxContext,
insightToMaxContext,
findPendingClientToolCall,
getContextSourceProperties,
isMultiQuestionFormMessage,
threadEndsWithMultiQuestionForm,
} from './utils'
describe('max/utils', () => {
it.each(['insight', 'dashboard'] as const)(
'removes nested query responses from %s context without changing the source',
(contextType) => {
const source = {
kind: NodeKind.HogQLQuery as const,
query: 'SELECT 1',
response: { results: [[1]] },
values: { response: 'keep this query value' },
}
const insight: Partial<InsightModel> = {
short_id: 'test-query' as InsightShortId,
query: {
kind: NodeKind.DataVisualizationNode,
source,
} as DataVisualizationNode,
}
const dashboard = {
id: 1,
tiles: [{ id: 1, insight }],
} as DashboardType
const context =
contextType === 'insight' ? insightToMaxContext(insight) : dashboardToMaxContext(dashboard).insights[0]
expect(context.query).toEqual({
kind: NodeKind.HogQLQuery as const,
query: 'SELECT 1',
values: { response: 'keep this query value' },
})
expect(source.response).toEqual({ results: [[1]] })
}
)
it('removes responses from direct queries and nested query arrays', () => {
const query = {
kind: NodeKind.TrendsQuery as const,
response: { results: [] },
series: [{ kind: NodeKind.EventsNode as const, event: '$pageview', response: { results: [] } }],
}
expect(insightToMaxContext({ query }).query).toEqual({
kind: NodeKind.TrendsQuery as const,
series: [{ kind: NodeKind.EventsNode as const, event: '$pageview' }],
})
expect(query.response).toEqual({ results: [] })
expect(query.series[0].response).toEqual({ results: [] })
})
describe('isMultiQuestionFormMessage()', () => {
it('returns true for AssistantMessage with create_form tool call', () => {
const message = {
type: AssistantMessageType.Assistant,
content: 'Please answer these questions',
tool_calls: [
{
id: 'tc-1',
name: 'create_form',
args: { questions: [] },
type: 'tool_call' as const,
},
],
} as unknown as AssistantMessage & { tool_calls: EnhancedToolCall[] }
expect(isMultiQuestionFormMessage(message)).toBe(true)
})
it('returns false for AssistantMessage without tool calls', () => {
const message = {
type: AssistantMessageType.Assistant,
content: 'Just a regular message',
} as unknown as AssistantMessage
expect(isMultiQuestionFormMessage(message)).toBe(false)
})
it('returns false for AssistantMessage with other tool calls', () => {
const message = {
type: AssistantMessageType.Assistant,
content: 'Using a different tool',
tool_calls: [
{
id: 'tc-1',
name: 'search',
args: {},
type: 'tool_call' as const,
},
],
} as unknown as AssistantMessage & { tool_calls: EnhancedToolCall[] }
expect(isMultiQuestionFormMessage(message)).toBe(false)
})
it('returns false for non-AssistantMessage types', () => {
const humanMessage = {
type: AssistantMessageType.Human,
content: 'Hello',
} as unknown as AssistantMessage & { tool_calls: EnhancedToolCall[] }
expect(isMultiQuestionFormMessage(humanMessage)).toBe(false)
const toolCallMessage = {
type: AssistantMessageType.ToolCall,
content: 'Tool result',
tool_call_id: 'tc-1',
} as unknown as AssistantToolCallMessage
expect(isMultiQuestionFormMessage(toolCallMessage)).toBe(false)
})
it('returns false for null or undefined', () => {
expect(isMultiQuestionFormMessage(null)).toBe(false)
expect(isMultiQuestionFormMessage(undefined)).toBe(false)
})
it('returns true when one of multiple tool calls is create_form', () => {
const message = {
type: AssistantMessageType.Assistant,
content: 'Multiple tools',
tool_calls: [
{
id: 'tc-1',
name: 'search',
args: { query: 'test' },
type: 'tool_call' as const,
},
{
id: 'tc-2',
name: 'create_form',
args: { questions: [] },
type: 'tool_call' as const,
},
{
id: 'tc-3',
name: 'analyze',
args: {},
type: 'tool_call' as const,
},
],
} as unknown as AssistantMessage & { tool_calls: EnhancedToolCall[] }
expect(isMultiQuestionFormMessage(message)).toBe(true)
})
it('returns false for empty tool_calls array', () => {
const message = {
type: AssistantMessageType.Assistant,
content: 'No tools',
tool_calls: [],
} as unknown as AssistantMessage & { tool_calls: EnhancedToolCall[] }
expect(isMultiQuestionFormMessage(message)).toBe(false)
})
})
describe('threadEndsWithMultiQuestionForm()', () => {
// With NodeInterrupt(None), the thread ends with the AssistantMessage containing
// the create_form tool call - no ToolCall message is created
it('returns true when last message is AssistantMessage with create_form tool call', () => {
const messages = [
{
type: AssistantMessageType.Human,
content: 'Hello',
},
{
type: AssistantMessageType.Assistant,
content: 'Please answer:',
tool_calls: [
{
id: 'tc-1',
name: 'create_form',
args: { questions: [] },
type: 'tool_call' as const,
},
],
},
] as unknown as RootAssistantMessage[]
expect(threadEndsWithMultiQuestionForm(messages)).toBe(true)
})
it('returns false for empty thread', () => {
expect(threadEndsWithMultiQuestionForm([])).toBe(false)
})
it('returns false when last message is AssistantMessage without tool calls', () => {
const messages = [
{
type: AssistantMessageType.Human,
content: 'Hello',
},
{
type: AssistantMessageType.Assistant,
content: 'Hi there!',
},
] as unknown as RootAssistantMessage[]
expect(threadEndsWithMultiQuestionForm(messages)).toBe(false)
})
it('returns false when last message is a ToolCall response (form already answered)', () => {
const messages = [
{
type: AssistantMessageType.Assistant,
content: 'Please answer:',
tool_calls: [
{
id: 'tc-1',
name: 'create_form',
args: { questions: [] },
type: 'tool_call' as const,
},
],
},
{
type: AssistantMessageType.ToolCall,
content: 'User answers',
tool_call_id: 'tc-1',
ui_payload: { create_form: { answers: { q1: 'answer1' } } },
},
] as unknown as RootAssistantMessage[]
expect(threadEndsWithMultiQuestionForm(messages)).toBe(false)
})
it('returns false when last message is AssistantMessage with non-create_form tool call', () => {
const messages = [
{
type: AssistantMessageType.Human,
content: 'Hello',
},
{
type: AssistantMessageType.Assistant,
content: 'Using search',
tool_calls: [
{
id: 'tc-1',
name: 'search',
args: {},
type: 'tool_call' as const,
},
],
},
] as unknown as RootAssistantMessage[]
expect(threadEndsWithMultiQuestionForm(messages)).toBe(false)
})
it('returns false when last message is HumanMessage', () => {
const messages = [
{
type: AssistantMessageType.Assistant,
content: 'Hi',
},
{
type: AssistantMessageType.Human,
content: 'Hello',
},
] as unknown as RootAssistantMessage[]
expect(threadEndsWithMultiQuestionForm(messages)).toBe(false)
})
})
describe('findPendingClientToolCall()', () => {
const clientToolNames = new Set(['my_client_tool'])
const humanMessage = (content: string): RootAssistantMessage =>
({ type: AssistantMessageType.Human, content }) as unknown as RootAssistantMessage
const toolResultMessage = (toolCallId: string): RootAssistantMessage =>
({
type: AssistantMessageType.ToolCall,
tool_call_id: toolCallId,
content: 'done',
}) as unknown as RootAssistantMessage
const assistantMessageWithCall = (id: string, name = 'my_client_tool'): RootAssistantMessage =>
({
type: AssistantMessageType.Assistant,
content: '',
tool_calls: [{ id, name, args: { payload: 'data' } }],
}) as unknown as RootAssistantMessage
it('finds a dangling client tool call at the end of the thread', () => {
const pending = findPendingClientToolCall([assistantMessageWithCall('tc-1')], clientToolNames)
expect(pending).toEqual({
toolName: 'my_client_tool',
toolCallId: 'tc-1',
args: { payload: 'data' },
})
})
it('finds a dangling client tool call even when a sibling tool result lands after it', () => {
const messages = [
humanMessage('Set up a parser'),
assistantMessageWithCall('tc-1'),
toolResultMessage('tc-other'), // a parallel server-side tool finished after
]
expect(findPendingClientToolCall(messages, clientToolNames)?.toolCallId).toBe('tc-1')
})
it('returns null when the client tool call already has a result message', () => {
const messages = [assistantMessageWithCall('tc-1'), toolResultMessage('tc-1')]
expect(findPendingClientToolCall(messages, clientToolNames)).toBeNull()
})
it('ignores dangling calls from previous turns', () => {
// An abandoned call followed by a new human message starts a fresh turn.
const messages = [
assistantMessageWithCall('tc-1'),
humanMessage('Never mind, do something else'),
{ type: AssistantMessageType.Assistant, content: 'Sure!' } as unknown as RootAssistantMessage,
]
expect(findPendingClientToolCall(messages, clientToolNames)).toBeNull()
})
it('returns null for tools that are not client-executed', () => {
const messages = [assistantMessageWithCall('tc-2', 'create_form')]
expect(findPendingClientToolCall(messages, clientToolNames)).toBeNull()
})
it('returns null for an empty thread or a thread ending with a human message', () => {
expect(findPendingClientToolCall([], clientToolNames)).toBeNull()
expect(findPendingClientToolCall([humanMessage('Hello')], clientToolNames)).toBeNull()
})
})
describe('activeSceneLogicHasMaxContext()', () => {
it('returns false for null or undefined scene logic', () => {
expect(activeSceneLogicHasMaxContext(null)).toBe(false)
expect(activeSceneLogicHasMaxContext(undefined)).toBe(false)
})
it.each([
{ mounted: true, hasMaxContext: true, expected: true },
{ mounted: true, hasMaxContext: false, expected: false },
// The crux of the fix: a built-but-unmounted scene logic must be rejected, since reading
// its selectors/values throws `[KEA] Can not find path` once its reducer path is gone.
{ mounted: false, hasMaxContext: true, expected: false },
{ mounted: false, hasMaxContext: false, expected: false },
])('mounted=$mounted hasMaxContext=$hasMaxContext -> $expected', ({ mounted, hasMaxContext, expected }) => {
const logic = {
isMounted: () => mounted,
selectors: hasMaxContext ? { maxContext: () => [] } : {},
} as unknown as BuiltLogic
expect(activeSceneLogicHasMaxContext(logic)).toBe(expected)
})
})
describe('getContextSourceProperties()', () => {
const sceneContext = [
{ type: MaxContextType.DASHBOARD, id: 1 },
{ type: MaxContextType.EVENT, id: 'pageview' },
] as MaxContextItem[]
it.each([
['no context', undefined, { context_source: 'none', page_context_count: 0, added_context_count: 0 }],
[
'only items from the page',
{ dashboards: [{ id: 1 }], events: [{ id: 'pageview' }] },
{ context_source: 'page', page_context_count: 2, added_context_count: 0 },
],
[
'only items the user added',
{ insights: [{ id: 'abc' }], events: [{ id: 'signup' }] },
{ context_source: 'added', page_context_count: 0, added_context_count: 2 },
],
[
'page and added items, with an id shared across types',
{ dashboards: [{ id: 1 }], actions: [{ id: 1 }] },
{ context_source: 'mixed', page_context_count: 1, added_context_count: 1 },
],
])('classifies %s', (_, uiContext, expected) => {
expect(getContextSourceProperties(uiContext as MaxUIContext | undefined, sceneContext)).toEqual(expected)
})
})
})