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.

16.5 KB
Raw Blame
// AUTO-GENERATED by generate-ui-apps.ts — do not edit
import type { App } from '@modelcontextprotocol/ext-apps'
import { useCallback } from 'react'

import { ActionListView, ActionView, type ActionData, type ActionListData } from 'products/actions/mcp/apps'
import { LLMCostsView, type LLMCostsData } from 'products/ai_observability/mcp/apps'
import { CohortListView, CohortView, type CohortData, type CohortListData } from 'products/cohorts/mcp/apps'
import {
    ErrorDetailsView,
    ErrorIssueListView,
    ErrorIssueView,
    type ErrorDetailsData,
    type ErrorIssueData,
    type ErrorIssueListData,
} from 'products/error_tracking/mcp/apps'
import {
    ExperimentListView,
    ExperimentResultsView,
    ExperimentView,
    type ExperimentData,
    type ExperimentListData,
    type ExperimentResultsData,
} from 'products/experiments/mcp/apps'
import {
    FeatureFlagListView,
    FeatureFlagTestingView,
    FeatureFlagView,
    type FeatureFlagData,
    type FeatureFlagListData,
    type FeatureFlagTestingData,
} from 'products/feature_flags/mcp/apps'
import { InsightActorsView, type InsightActorsData } from 'products/product_analytics/mcp/apps'
import { SessionRecordingView, type SessionRecordingData } from 'products/replay/mcp/apps'
import {
    InlineScanView,
    VisionObservationListView,
    type InlineScanData,
    type VisionObservationData,
    type VisionObservationListData,
} from 'products/replay_vision/mcp/apps'
import {
    SurveyListView,
    SurveyStatsView,
    SurveyView,
    type SurveyData,
    type SurveyListData,
    type SurveyStatsData,
} from 'products/surveys/mcp/apps'
import { TraceSpanListView, TraceSpanView, type TraceSpanData, type TraceSpanListData } from 'products/tracing/mcp/apps'
import {
    EmailTemplateView,
    WorkflowListView,
    WorkflowSendingRulesView,
    WorkflowSetupStatusView,
    WorkflowView,
    type EmailTemplateData,
    type WorkflowData,
    type WorkflowListData,
    type WorkflowSendingRulesData,
    type WorkflowSetupStatusData,
} from 'products/workflows/mcp/apps'

import type { UiAppKey } from '../../resources/ui-apps.generated'
import { Component } from '../components/Component'
import { ExplainChart, type ExplainChartData } from '../components/ExplainChart'

export interface RenderDispatchProps {
    data: unknown
    app: App | null
    openLink: (url: string) => void
}

function ActionListContent({ data, app }: { data: ActionListData; app: App | null }): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for action "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: ActionData): Promise<ActionData | null> => {
            if (!app) {
                fallbackToChat(item.name)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'action-get',
                    arguments: { id: item.id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.name)
                    return null
                }
                return result.structuredContent as unknown as ActionData
            } catch {
                fallbackToChat(item.name)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <ActionListView data={data} onActionClick={handleClick} />
}

function CohortListContent({ data, app }: { data: CohortListData; app: App | null }): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for cohort "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: CohortData): Promise<CohortData | null> => {
            if (!app) {
                fallbackToChat(item.name)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'cohorts-retrieve',
                    arguments: { id: item.id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.name)
                    return null
                }
                return result.structuredContent as unknown as CohortData
            } catch {
                fallbackToChat(item.name)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <CohortListView data={data} onCohortClick={handleClick} />
}

function ErrorIssueListContent({ data, app }: { data: ErrorIssueListData; app: App | null }): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for error issue "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: ErrorIssueData): Promise<ErrorIssueData | null> => {
            if (!app) {
                fallbackToChat(item.name)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'query-error-tracking-issue',
                    arguments: { issueId: item.id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.name)
                    return null
                }
                return result.structuredContent as unknown as ErrorIssueData
            } catch {
                fallbackToChat(item.name)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <ErrorIssueListView data={data} onIssueClick={handleClick} />
}

function ExperimentListContent({ data, app }: { data: ExperimentListData; app: App | null }): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for experiment "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: ExperimentData): Promise<ExperimentData | null> => {
            if (!app) {
                fallbackToChat(item.name)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'experiment-get',
                    arguments: { id: item.id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.name)
                    return null
                }
                return result.structuredContent as unknown as ExperimentData
            } catch {
                fallbackToChat(item.name)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <ExperimentListView data={data} onExperimentClick={handleClick} />
}

function FeatureFlagListContent({ data, app }: { data: FeatureFlagListData; app: App | null }): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for feature flag "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: FeatureFlagData): Promise<FeatureFlagData | null> => {
            if (!app) {
                fallbackToChat(item.key)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'feature-flag-get-definition',
                    arguments: { id: item.id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.key)
                    return null
                }
                return result.structuredContent as unknown as FeatureFlagData
            } catch {
                fallbackToChat(item.key)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <FeatureFlagListView data={data} onFlagClick={handleClick} />
}

function SurveyListContent({ data, app }: { data: SurveyListData; app: App | null }): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for survey "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: SurveyData): Promise<SurveyData | null> => {
            if (!app) {
                fallbackToChat(item.name)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'survey-get',
                    arguments: { id: item.id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.name)
                    return null
                }
                return result.structuredContent as unknown as SurveyData
            } catch {
                fallbackToChat(item.name)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <SurveyListView data={data} onSurveyClick={handleClick} />
}

function TraceSpanListContent({ data, app }: { data: TraceSpanListData; app: App | null }): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for trace span "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: TraceSpanData): Promise<TraceSpanData | null> => {
            if (!app) {
                fallbackToChat(item.name)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'apm-trace-get',
                    arguments: { trace_id: item.trace_id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.name)
                    return null
                }
                return result.structuredContent as unknown as TraceSpanData
            } catch {
                fallbackToChat(item.name)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <TraceSpanListView data={data} onSpanClick={handleClick} />
}

function VisionObservationListContent({
    data,
    app,
}: {
    data: VisionObservationListData
    app: App | null
}): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for observation "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: VisionObservationData): Promise<VisionObservationData | null> => {
            if (!app) {
                fallbackToChat(item.id)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'vision-observations-get',
                    arguments: { id: item.id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.id)
                    return null
                }
                return result.structuredContent as unknown as VisionObservationData
            } catch {
                fallbackToChat(item.id)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <VisionObservationListView data={data} onVisionObservationClick={handleClick} />
}

function WorkflowListContent({ data, app }: { data: WorkflowListData; app: App | null }): JSX.Element {
    const fallbackToChat = useCallback(
        (name: string) => {
            app?.sendMessage({
                role: 'user',
                content: [{ type: 'text', text: `Show me the details for workflow "${name}"` }],
            })
        },
        [app]
    )

    const handleClick = useCallback(
        async (item: WorkflowData): Promise<WorkflowData | null> => {
            if (!app) {
                fallbackToChat(item.name)
                return null
            }
            try {
                const result = await app.callServerTool({
                    name: 'workflows-get',
                    arguments: { id: item.id },
                })
                if (result.isError || !result.structuredContent) {
                    fallbackToChat(item.name)
                    return null
                }
                return result.structuredContent as unknown as WorkflowData
            } catch {
                fallbackToChat(item.name)
                return null
            }
        },
        [app, fallbackToChat]
    )

    return <WorkflowListView data={data} onWorkflowClick={handleClick} />
}

export const RENDER_DISPATCH: Partial<Record<UiAppKey, (props: RenderDispatchProps) => JSX.Element>> = {
    action: ({ data }) => <ActionView action={data as ActionData} />,
    'action-list': ({ data, app }) => <ActionListContent data={data as ActionListData} app={app} />,
    cohort: ({ data }) => <CohortView cohort={data as CohortData} />,
    'cohort-list': ({ data, app }) => <CohortListContent data={data as CohortListData} app={app} />,
    'email-template': ({ data }) => <EmailTemplateView template={data as EmailTemplateData} />,
    'error-details': ({ data }) => <ErrorDetailsView data={data as ErrorDetailsData} />,
    'error-issue': ({ data }) => <ErrorIssueView issue={data as ErrorIssueData} />,
    'error-issue-list': ({ data, app }) => <ErrorIssueListContent data={data as ErrorIssueListData} app={app} />,
    experiment: ({ data }) => <ExperimentView experiment={data as ExperimentData} />,
    'experiment-list': ({ data, app }) => <ExperimentListContent data={data as ExperimentListData} app={app} />,
    'experiment-results': ({ data }) => <ExperimentResultsView data={data as ExperimentResultsData} />,
    'explain-chart': ({ data, openLink, app }) => (
        <ExplainChart data={data as ExplainChartData} openLink={openLink} app={app} />
    ),
    'feature-flag': ({ data }) => <FeatureFlagView flag={data as FeatureFlagData} />,
    'feature-flag-list': ({ data, app }) => <FeatureFlagListContent data={data as FeatureFlagListData} app={app} />,
    'feature-flag-testing': ({ data }) => <FeatureFlagTestingView flag={data as FeatureFlagTestingData} />,
    'inline-scan': ({ data }) => <InlineScanView data={data as InlineScanData} />,
    'insight-actors': ({ data, openLink }) => (
        <InsightActorsView data={data as InsightActorsData} openLink={openLink} />
    ),
    'llm-costs': ({ data }) => <LLMCostsView data={data as LLMCostsData} />,
    'query-results': ({ data }) => <Component data={data} />,
    'session-recording': ({ data }) => <SessionRecordingView recording={data as SessionRecordingData} />,
    survey: ({ data }) => <SurveyView survey={data as SurveyData} />,
    'survey-global-stats': ({ data }) => <SurveyStatsView data={data as SurveyStatsData} />,
    'survey-list': ({ data, app }) => <SurveyListContent data={data as SurveyListData} app={app} />,
    'survey-stats': ({ data }) => <SurveyStatsView data={data as SurveyStatsData} />,
    'trace-span': ({ data }) => <TraceSpanView data={data as TraceSpanData} />,
    'trace-span-list': ({ data, app }) => <TraceSpanListContent data={data as TraceSpanListData} app={app} />,
    'vision-observation-list': ({ data, app }) => (
        <VisionObservationListContent data={data as VisionObservationListData} app={app} />
    ),
    workflow: ({ data }) => <WorkflowView workflow={data as WorkflowData} />,
    'workflow-list': ({ data, app }) => <WorkflowListContent data={data as WorkflowListData} app={app} />,
    'workflow-sending-rules': ({ data }) => <WorkflowSendingRulesView data={data as WorkflowSendingRulesData} />,
    'workflow-setup-status': ({ data, openLink }) => (
        <WorkflowSetupStatusView data={data as WorkflowSetupStatusData} openLink={openLink} />
    ),
}