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.

39.4 KB
Raw Blame
import { useActions, useMountedLogic, useValues } from 'kea'
import posthog from 'posthog-js'
import { useCallback, useEffect, useMemo, useRef, useState } from 'react'

import { IconGraph } from '@posthog/icons'
import { lemonToast } from '@posthog/lemon-ui'

import {
    MarkdownNotebook,
    NotebookComponentRunStatusContext,
    PRODUCTS_INSERT_COMMAND_CATEGORY,
    parseMarkdownNotebook,
} from 'lib/components/MarkdownNotebook'
import type {
    InsertCommand,
    MarkdownNotebookAskAIRequest,
    MarkdownNotebookInsertMenuApi,
} from 'lib/components/MarkdownNotebook'
import { makeEmptyParagraph } from 'lib/components/MarkdownNotebook/markdown'
import {
    insertNotebookAIFollowUpPromptAfterResponse,
    preserveNotebookAIQuestion,
    rebaseNotebookAIResponseRange,
    replaceNotebookAIResponseMarkdown,
    streamNotebookAIResponseMarkdown,
} from 'lib/components/MarkdownNotebook/notebookAI'
import type { MarkdownNotebookCaretPosition, RemoteNotebookCaret } from 'lib/components/MarkdownNotebook/remoteCarets'
import type { NotebookBlockNode, NotebookComponentProps } from 'lib/components/MarkdownNotebook/types'
import { getInlineText } from 'lib/components/MarkdownNotebook/utils'
import { uploadFile } from 'lib/hooks/useUploadFiles'
import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
import { uuid } from 'lib/utils/dom'
import { userLogic } from 'scenes/userLogic'

import { aiConsentLogic } from '~/layout/ai/aiConsentLogic'
import type { NotebookArtifactContent } from '~/queries/schema/schema-assistant-messages'

import { NotebookBtwLayout } from 'products/notebooks/frontend/NotebookBtwLayout'
import { notebookBtwLogic } from 'products/notebooks/frontend/notebookBtwLogic'

import { NODE_ICONS } from '../nodeIcons'
import { notebookWidgetCatalog, NotebookWidgetPickerKind } from '../notebookWidgetCatalog'
import { NotebookNodeType } from '../types'
import { isJupyterModeAvailable } from '../utils'
import {
    MarkdownNotebookEntityPicker,
    MarkdownNotebookEntityPickerKind,
    MarkdownNotebookEntityPickerSelection,
} from './MarkdownNotebookEntityPicker'
import { InlineAIAssistantMessage, InlineAICompletion, InlineNotebookAIRunner } from './MarkdownNotebookInlineAI'
import {
    getHiddenInsertCommandKeysForFeatureFlags,
    getMarkdownRegistryForFeatureFlags,
} from './markdownNotebookRegistry'
import { useNotebookComponentRunStatusResolver } from './markdownNotebookRunStatus'
import {
    InlineNotebookAIRequest,
    MarkdownNotebookRuntimeContext,
    MarkdownNotebookRuntimeContextValue,
    NotebookArtifactApplyMode,
    getInlineNotebookAIPanelId,
    getInlineNotebookAIUIContext,
} from './markdownNotebookRuntime'
import {
    buildDroppedLinkParagraphNode,
    convertDroppedPostHogUrlToMarkdownNode,
    convertDroppedRichContentNodeToMarkdownNode,
    getMarkdownNotebookMarkdown,
    notebookArtifactContentToMarkdown,
} from './markdownNotebookV2'
import { buildNotebookInlineAIFinishedEvent, buildNotebookInlineAIRequestedEvent } from './notebookAnalytics'
import { notebookJupyterLogic } from './notebookJupyterLogic'
import { getNotebookJupyterModeConfig } from './notebookJupyterMode'
import { NotebookJupyterToolbar } from './NotebookJupyterToolbar'
import { notebookLogic } from './notebookLogic'
import {
    NOTEBOOK_AI_PRESENCE_COLOR,
    NOTEBOOK_AI_PRESENCE_CLIENT_ID,
    NOTEBOOK_AI_PRESENCE_NAME,
} from './notebookPresence'
import { notebookSettingsLogic } from './notebookSettingsLogic'
import { NotebookVariablesBar } from './NotebookVariablesBar'

const NOTEBOOK_AI_FOLLOW_UP_PROMPT_MARKDOWN = '<Prompt question="" />'
const NOTEBOOK_AI_PRESENCE_DEPARTURE_IDLE_MS = 5_000
const NOTEBOOK_AI_PRESENCE_FADE_OUT_MS = 300

type MarkdownNotebookV2Props = {
    collapsedToolbarContainer?: HTMLElement | null
    debugOpen?: boolean
    onDebugOpenChange?: (isOpen: boolean) => void
}

export function MarkdownNotebookV2({
    collapsedToolbarContainer,
    debugOpen,
    onDebugOpenChange,
}: MarkdownNotebookV2Props): JSX.Element {
    const mountedNotebookLogic = useMountedLogic(notebookLogic)
    const {
        isEditable,
        isShared,
        notebook,
        shortId,
        markdownEditorValue,
        markdownEditorInteractionActive,
        markdownRemoteCarets,
    } = useValues(notebookLogic)
    const { featureFlags } = useValues(featureFlagLogic)
    const { user } = useValues(userLogic)
    const { dataProcessingAccepted } = useValues(aiConsentLogic)
    const { session: btwSession } = useValues(notebookBtwLogic({ shortId }))
    const { openBtw, closeBtw } = useActions(notebookBtwLogic({ shortId }))
    const markdownRegistry = useMemo(() => getMarkdownRegistryForFeatureFlags(featureFlags), [featureFlags])
    const enabledAIComponentTags = useMemo(
        () => [
            'Query',
            ...Object.entries(markdownRegistry.components)
                .filter(([, definition]) => definition.insertCommand)
                .map(([tag]) => tag),
        ],
        [markdownRegistry]
    )
    const hiddenInsertCommandKeys = useMemo(
        () => getHiddenInsertCommandKeysForFeatureFlags(featureFlags),
        [featureFlags]
    )
    const resolveComponentRunStatus = useNotebookComponentRunStatusResolver(mountedNotebookLogic.props.shortId)
    const {
        handleMarkdownEditorChange,
        setMarkdownEditorInteractionActive,
        applyNotebookArtifactMarkdown,
        reportMarkdownMergeConflicts,
        publishMarkdownCaret,
        setMarkdownAIPresenceActive,
        saveNotebookNow,
    } = useActions(notebookLogic)
    const { setShowKernelInfo } = useActions(notebookSettingsLogic)
    const { isJupyterMode } = useValues(notebookSettingsLogic)
    const { requestKernelRestart, trackCommand, setIsActive } = useActions(notebookJupyterLogic({ shortId }))
    // Canvases (customer profiles and the like) are not notebooks of cells, so they keep their layout.
    const jupyterMode = useMemo(
        () =>
            isJupyterModeAvailable(featureFlags) && isJupyterMode && mountedNotebookLogic.props.mode !== 'canvas'
                ? getNotebookJupyterModeConfig(shortId, {
                      onRestartKernel: () => requestKernelRestart(),
                      onCommand: trackCommand,
                  })
                : null,
        [featureFlags, isJupyterMode, mountedNotebookLogic.props.mode, requestKernelRestart, trackCommand, shortId]
    )
    useEffect(() => {
        setIsActive(!!jupyterMode)
    }, [jupyterMode, setIsActive])
    const remoteMarkdown = useMemo(() => getMarkdownNotebookMarkdown(notebook?.content), [notebook?.content])
    const [inlineAIRequests, setInlineAIRequests] = useState<InlineNotebookAIRequest[]>([])
    const [aiCaretPosition, setAICaretPosition] = useState<MarkdownNotebookCaretPosition | null>(null)
    const [aiCaretFading, setAICaretFading] = useState(false)
    const [aiCaretThinking, setAICaretThinking] = useState(false)
    const markdownEditorValueRef = useRef(markdownEditorValue)
    const inlineAIResponseNodeCountsRef = useRef<Record<string, number>>({})
    const inlineAIResponseNodeIndicesRef = useRef<Record<string, number>>({})
    const activeInlineAIRequestIdsRef = useRef<Set<string>>(new Set())
    const inlineAIRequestStartedAtRef = useRef<Record<string, number>>({})
    const aiPresenceRetainedByPromptRef = useRef(false)
    const aiPresenceActivityVersionRef = useRef(0)
    const aiPresenceDepartureTimeoutRef = useRef<number | null>(null)
    const aiPresenceFadeTimeoutRef = useRef<number | null>(null)
    const [focusAIPromptRequest, setFocusAIPromptRequest] = useState<number | undefined>(undefined)
    const [internalDebugOpen, setInternalDebugOpen] = useState(false)
    const isDebugOpen = debugOpen ?? internalDebugOpen

    useEffect(() => {
        markdownEditorValueRef.current = markdownEditorValue
    }, [markdownEditorValue])

    const setMarkdownSourceOpen = useCallback(
        (isOpen: boolean): void => {
            if (debugOpen === undefined) {
                setInternalDebugOpen(isOpen)
            }
            onDebugOpenChange?.(isOpen)
        },
        [debugOpen, onDebugOpenChange]
    )

    const handleDebugOpenChange = useCallback(
        (isOpen: boolean): void => {
            if (isOpen) {
                setShowKernelInfo(false)
            }
            setMarkdownSourceOpen(isOpen)
        },
        [setMarkdownSourceOpen, setShowKernelInfo]
    )

    const updateMarkdownEditorValue = useCallback(
        (updater: (markdown: string) => string): void => {
            const currentMarkdown = markdownEditorValueRef.current
            const nextMarkdown = updater(currentMarkdown)
            if (nextMarkdown === currentMarkdown) {
                return
            }
            markdownEditorValueRef.current = nextMarkdown
            handleMarkdownEditorChange(nextMarkdown)
        },
        [handleMarkdownEditorChange]
    )

    const handleMarkdownNotebookChange = useCallback(
        (markdown: string): void => {
            const previousMarkdown = markdownEditorValueRef.current
            for (const request of inlineAIRequests) {
                const currentRange = rebaseNotebookAIResponseRange(
                    previousMarkdown,
                    markdown,
                    getInlineAIResponseNodeIndex(request, inlineAIResponseNodeIndicesRef.current),
                    inlineAIResponseNodeCountsRef.current[request.conversationId] ?? 1
                )
                inlineAIResponseNodeIndicesRef.current[request.conversationId] = currentRange.responseNodeIndex
                inlineAIResponseNodeCountsRef.current[request.conversationId] = currentRange.responseNodeCount
            }
            markdownEditorValueRef.current = markdown
            handleMarkdownEditorChange(markdown)
        },
        [handleMarkdownEditorChange, inlineAIRequests]
    )

    const clearAIPresenceDepartureTimeout = useCallback((): void => {
        if (aiPresenceDepartureTimeoutRef.current !== null) {
            window.clearTimeout(aiPresenceDepartureTimeoutRef.current)
            aiPresenceDepartureTimeoutRef.current = null
        }
    }, [])

    const clearAIPresenceFadeTimeout = useCallback((): void => {
        if (aiPresenceFadeTimeoutRef.current !== null) {
            window.clearTimeout(aiPresenceFadeTimeoutRef.current)
            aiPresenceFadeTimeoutRef.current = null
        }
    }, [])

    const clearAIPresenceTimeouts = useCallback((): void => {
        clearAIPresenceDepartureTimeout()
        clearAIPresenceFadeTimeout()
    }, [clearAIPresenceDepartureTimeout, clearAIPresenceFadeTimeout])

    const finishAIPresenceDeparture = useCallback(
        (scheduledActivityVersion: number): void => {
            if (
                scheduledActivityVersion !== aiPresenceActivityVersionRef.current ||
                activeInlineAIRequestIdsRef.current.size > 0 ||
                aiPresenceRetainedByPromptRef.current
            ) {
                setAICaretFading(false)
                return
            }

            setAICaretPosition(null)
            setAICaretFading(false)
            setAICaretThinking(false)
            setMarkdownAIPresenceActive(false)
        },
        [setMarkdownAIPresenceActive]
    )

    const scheduleAIPresenceDeparture = useCallback((): void => {
        clearAIPresenceTimeouts()
        if (activeInlineAIRequestIdsRef.current.size > 0 || aiPresenceRetainedByPromptRef.current) {
            return
        }

        const scheduledActivityVersion = aiPresenceActivityVersionRef.current
        aiPresenceDepartureTimeoutRef.current = window.setTimeout(() => {
            aiPresenceDepartureTimeoutRef.current = null
            if (
                scheduledActivityVersion !== aiPresenceActivityVersionRef.current ||
                activeInlineAIRequestIdsRef.current.size > 0 ||
                aiPresenceRetainedByPromptRef.current
            ) {
                return
            }

            setAICaretFading(true)
            aiPresenceFadeTimeoutRef.current = window.setTimeout(() => {
                aiPresenceFadeTimeoutRef.current = null
                finishAIPresenceDeparture(scheduledActivityVersion)
            }, NOTEBOOK_AI_PRESENCE_FADE_OUT_MS)
        }, NOTEBOOK_AI_PRESENCE_DEPARTURE_IDLE_MS)
    }, [clearAIPresenceTimeouts, finishAIPresenceDeparture])

    const markAIPresenceActive = useCallback(
        (conversationId: string): void => {
            activeInlineAIRequestIdsRef.current.add(conversationId)
            aiPresenceActivityVersionRef.current += 1
            clearAIPresenceTimeouts()
            setAICaretFading(false)
            setAICaretThinking(true)
            setMarkdownAIPresenceActive(true)
        },
        [clearAIPresenceTimeouts, setMarkdownAIPresenceActive]
    )

    const retainAIPresenceForPrompt = useCallback((): void => {
        const promptCaretPosition = getNotebookAIPromptCaretPosition(markdownEditorValueRef.current)
        if (!promptCaretPosition) {
            return
        }

        if (!aiPresenceRetainedByPromptRef.current) {
            aiPresenceActivityVersionRef.current += 1
        }
        aiPresenceRetainedByPromptRef.current = true
        clearAIPresenceTimeouts()
        setAICaretFading(false)
        setAICaretThinking(false)
        setAICaretPosition(promptCaretPosition)
        setMarkdownAIPresenceActive(true)
    }, [clearAIPresenceTimeouts, setMarkdownAIPresenceActive])

    const markAIPresenceInactive = useCallback(
        (conversationId: string): void => {
            activeInlineAIRequestIdsRef.current.delete(conversationId)
            if (activeInlineAIRequestIdsRef.current.size === 0) {
                setAICaretThinking(false)
            }
            scheduleAIPresenceDeparture()
        },
        [scheduleAIPresenceDeparture]
    )

    useEffect(() => clearAIPresenceTimeouts, [clearAIPresenceTimeouts])

    useEffect(
        () => () => {
            aiPresenceRetainedByPromptRef.current = false
            setMarkdownAIPresenceActive(false)
        },
        [setMarkdownAIPresenceActive]
    )

    useEffect(() => {
        const promptCaretPosition = getNotebookAIPromptCaretPosition(markdownEditorValue)
        if (promptCaretPosition) {
            if (!aiPresenceRetainedByPromptRef.current) {
                aiPresenceActivityVersionRef.current += 1
            }
            aiPresenceRetainedByPromptRef.current = true
            clearAIPresenceTimeouts()
            setAICaretFading(false)
            setAICaretThinking(false)
            setAICaretPosition(promptCaretPosition)
            setMarkdownAIPresenceActive(true)
            return
        }

        if (!aiPresenceRetainedByPromptRef.current) {
            return
        }

        aiPresenceRetainedByPromptRef.current = false
        scheduleAIPresenceDeparture()
    }, [clearAIPresenceTimeouts, markdownEditorValue, scheduleAIPresenceDeparture, setMarkdownAIPresenceActive])

    const aiCarets = useMemo<RemoteNotebookCaret[]>(
        () =>
            aiCaretPosition
                ? [
                      {
                          clientId: NOTEBOOK_AI_PRESENCE_CLIENT_ID,
                          userName: NOTEBOOK_AI_PRESENCE_NAME,
                          color: NOTEBOOK_AI_PRESENCE_COLOR,
                          position: aiCaretPosition,
                          version: notebook?.version,
                          isAI: true,
                          isAIThinking: aiCaretThinking,
                          isFading: aiCaretFading,
                      },
                  ]
                : [],
        [aiCaretFading, aiCaretPosition, aiCaretThinking, notebook?.version]
    )
    const remoteCarets = useMemo<RemoteNotebookCaret[]>(
        () => [...markdownRemoteCarets, ...aiCarets],
        [aiCarets, markdownRemoteCarets]
    )

    const handleAskAI = useCallback(
        ({
            conversationId,
            query,
            source,
            responseNodeId,
            responseNodeIndex,
            responseMarker,
            markdown,
            markdownWithResponse,
            selectedMarkdown,
            selectedRefId,
            retainedQuestionMarkdown,
        }: MarkdownNotebookAskAIRequest): void => {
            markAIPresenceActive(conversationId)
            setAICaretPosition(getNotebookAICaretPosition(markdownWithResponse, responseNodeIndex))
            const uiContext = getInlineNotebookAIUIContext({
                // A canvas has no saved notebook, so fall back to the logic's short id. Without it the
                // structured context is dropped and the request reaches the model with no document.
                notebookShortId: notebook?.short_id ?? shortId,
                notebookTitle: notebook?.title ?? 'Untitled notebook',
                markdown: markdownWithResponse,
                conversationId,
                responseMarker: responseMarker,
            })

            const inlineAIRequest: InlineNotebookAIRequest = {
                conversationId,
                panelId: getInlineNotebookAIPanelId(conversationId, 'inline'),
                query,
                source,
                responseNodeId,
                responseNodeIndex,
                responseMarker,
                markdown,
                markdownWithResponse,
                selectedMarkdown,
                selectedRefId,
                retainedQuestionMarkdown,
                uiContext,
            }
            setInlineAIRequests((currentRequests) => [
                ...currentRequests.filter((currentRequest) => currentRequest.conversationId !== conversationId),
                inlineAIRequest,
            ])
            inlineAIResponseNodeCountsRef.current[conversationId] = 1
            inlineAIResponseNodeIndicesRef.current[conversationId] = responseNodeIndex
            inlineAIRequestStartedAtRef.current[conversationId] = Date.now()
            // pinned: analytics event name and property names; renaming breaks dashboards
            posthog.capture(
                'notebook inline ai requested',
                buildNotebookInlineAIRequestedEvent(inlineAIRequest, notebook?.short_id ?? shortId)
            )
        },
        [markAIPresenceActive, notebook?.short_id, notebook?.title, shortId]
    )

    const getInlineAIRequest = useCallback(
        (conversationId: string | undefined): InlineNotebookAIRequest | null => {
            if (!conversationId) {
                return null
            }
            return inlineAIRequests.find((request) => request.conversationId === conversationId) ?? null
        },
        [inlineAIRequests]
    )

    const applyNotebookArtifactContent = useCallback(
        (
            content: NotebookArtifactContent,
            conversationId?: string,
            mode: NotebookArtifactApplyMode = 'replace'
        ): void => {
            const inlineAIRequest = getInlineAIRequest(conversationId)
            if (inlineAIRequest) {
                const artifactMarkdown = preserveNotebookAIQuestion(
                    notebookArtifactContentToMarkdown(content),
                    mode === 'replace' ? inlineAIRequest.retainedQuestionMarkdown : undefined
                )
                if (mode === 'replace') {
                    updateMarkdownEditorValue(() => artifactMarkdown)
                    inlineAIResponseNodeCountsRef.current[inlineAIRequest.conversationId] = 1
                    const responseNodeIndex = Math.max(0, getMarkdownBlockCount(artifactMarkdown) - 1)
                    inlineAIResponseNodeIndicesRef.current[inlineAIRequest.conversationId] = responseNodeIndex
                    setAICaretPosition(getNotebookAICaretPosition(artifactMarkdown, responseNodeIndex))
                    return
                }

                const replacedNodeCount = inlineAIResponseNodeCountsRef.current[inlineAIRequest.conversationId] ?? 1
                updateMarkdownEditorValue((currentMarkdown) => {
                    const result = replaceNotebookAIResponseMarkdown(
                        currentMarkdown,
                        getInlineAIResponseNodeIndex(inlineAIRequest, inlineAIResponseNodeIndicesRef.current),
                        artifactMarkdown,
                        replacedNodeCount,
                        enabledAIComponentTags
                    )
                    inlineAIResponseNodeIndicesRef.current[inlineAIRequest.conversationId] = result.responseNodeIndex
                    setAICaretPosition(getNotebookAICaretPosition(result.markdown, result.responseNodeIndex))
                    return result.markdown
                })
                inlineAIResponseNodeCountsRef.current[inlineAIRequest.conversationId] =
                    getMarkdownBlockCount(artifactMarkdown)
                return
            }

            applyNotebookArtifactMarkdown(content, conversationId, mode)
        },
        [applyNotebookArtifactMarkdown, getInlineAIRequest, updateMarkdownEditorValue, enabledAIComponentTags]
    )

    const [openEntityPicker, setOpenEntityPicker] = useState<MarkdownNotebookEntityPickerKind | null>(null)
    // Insert API + target node captured when a picker command runs, so the modal's async
    // selection can insert into the right node once an entity is chosen.
    const pendingEntityInsertRef = useRef<{ api: MarkdownNotebookInsertMenuApi; targetNodeId: string } | null>(null)

    const buildExtraInsertCommands = useCallback((api: MarkdownNotebookInsertMenuApi): InsertCommand[] => {
        const pickerCommand = (
            key: string,
            label: string,
            icon: JSX.Element,
            picker: MarkdownNotebookEntityPickerKind,
            aliases?: string[]
        ): InsertCommand => ({
            key,
            label,
            category: PRODUCTS_INSERT_COMMAND_CATEGORY,
            icon,
            aliases,
            run: (targetNodeId) => {
                pendingEntityInsertRef.current = { api, targetNodeId }
                setOpenEntityPicker(picker)
            },
        })

        return Object.entries(notebookWidgetCatalog.widgets).map(([tagName, widget]) =>
            pickerCommand(
                `product-${tagName.replaceAll(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()}`,
                widget.label,
                NODE_ICONS[widget.nodeType as NotebookNodeType] || <IconGraph />,
                widget.picker as NotebookWidgetPickerKind
            )
        )
    }, [])

    const closeEntityPicker = useCallback((): void => {
        pendingEntityInsertRef.current = null
        setOpenEntityPicker(null)
    }, [])

    // Inserts the picked entity's component into the node the picker command targeted, then
    // closes the picker.
    const insertPickedComponent = useCallback(({ tagName, props }: MarkdownNotebookEntityPickerSelection): void => {
        const pending = pendingEntityInsertRef.current
        if (pending) {
            pending.api.insertComponent(pending.targetNodeId, tagName, props as NotebookComponentProps)
        }
        pendingEntityInsertRef.current = null
        setOpenEntityPicker(null)
    }, [])

    const convertExternalDataTransferToNodes = useCallback(
        (dataTransfer: DataTransfer): NotebookBlockNode[] | Promise<NotebookBlockNode[] | null> | null => {
            const nodeType = dataTransfer.getData('node')
            if (nodeType) {
                let attrs: Record<string, unknown> = {}
                const propertiesJson = dataTransfer.getData('properties')
                if (propertiesJson) {
                    try {
                        attrs = JSON.parse(propertiesJson)
                    } catch {
                        return null
                    }
                }

                const node = convertDroppedRichContentNodeToMarkdownNode(nodeType, attrs)
                if (node) {
                    posthog.capture('notebook node dropped', { node_type: nodeType, is_markdown: true })
                }
                return node ? [node] : null
            }

            // Entity links (`Link`) drag with only their href: map recognized PostHog resource
            // URLs to their component node, and keep anything else as a plain link block.
            const draggedUrl = (dataTransfer.getData('text/uri-list') ?? '')
                .split('\n')
                .map((line) => line.trim())
                .find((line) => line && !line.startsWith('#'))
            if (draggedUrl) {
                const resourceNode = convertDroppedPostHogUrlToMarkdownNode(draggedUrl)
                posthog.capture('notebook node dropped', {
                    node_type: resourceNode?.type === 'component' ? resourceNode.tagName : 'link',
                    is_markdown: true,
                })
                return [resourceNode ?? buildDroppedLinkParagraphNode(draggedUrl)]
            }

            const files = Array.from(dataTransfer.files ?? [])
            if (files.length) {
                const imageFiles = files.filter((file) => file.type.startsWith('image/'))
                if (imageFiles.length < files.length) {
                    lemonToast.warning('Only images can be added to notebooks at this time.')
                }
                if (!imageFiles.length) {
                    return null
                }

                posthog.capture('notebook files dropped', {
                    file_types: imageFiles.map((file) => file.type),
                    is_markdown: true,
                })
                // allSettled so one failed upload doesn't discard the files that uploaded fine.
                return Promise.allSettled(
                    imageFiles.map(async (file): Promise<NotebookBlockNode> => {
                        const media = await uploadFile(file)
                        return {
                            id: makeEmptyParagraph('dropped-image').id,
                            type: 'component',
                            tagName: 'Image',
                            props: { src: media.image_location, alt: media.name },
                        }
                    })
                ).then((results): NotebookBlockNode[] | null => {
                    const uploadedNodes = results
                        .filter(
                            (result): result is PromiseFulfilledResult<NotebookBlockNode> =>
                                result.status === 'fulfilled'
                        )
                        .map((result) => result.value)
                    const firstRejection = results.find(
                        (result): result is PromiseRejectedResult => result.status === 'rejected'
                    )
                    if (firstRejection) {
                        const failedCount = results.length - uploadedNodes.length
                        const { detail, message } = (firstRejection.reason ?? {}) as {
                            detail?: string
                            message?: string
                        }
                        lemonToast.error(
                            `${failedCount === 1 ? 'Image upload' : `${failedCount} image uploads`} failed: ${detail ?? message ?? 'unknown error'}`
                        )
                    }
                    return uploadedNodes.length ? uploadedNodes : null
                })
            }

            return null
        },
        []
    )

    const runtimeContext = useMemo<MarkdownNotebookRuntimeContextValue>(
        () => ({
            notebookShortId: notebook?.short_id ?? null,
            notebookTitle: notebook?.title ?? 'Untitled notebook',
            markdown: markdownEditorValue,
            applyNotebookArtifactContent,
        }),
        [applyNotebookArtifactContent, notebook?.short_id, notebook?.title, markdownEditorValue]
    )

    const handleInlineAIAssistantMessage = useCallback(
        (request: InlineNotebookAIRequest, message: InlineAIAssistantMessage): void => {
            if (message.hasArtifact) {
                return
            }

            const replacedNodeCount = inlineAIResponseNodeCountsRef.current[request.conversationId] ?? 1
            updateMarkdownEditorValue((currentMarkdown) => {
                const result = streamNotebookAIResponseMarkdown(
                    currentMarkdown,
                    getInlineAIResponseNodeIndex(request, inlineAIResponseNodeIndicesRef.current),
                    message.content,
                    replacedNodeCount,
                    enabledAIComponentTags
                )
                inlineAIResponseNodeIndicesRef.current[request.conversationId] = result.responseNodeIndex
                inlineAIResponseNodeCountsRef.current[request.conversationId] = result.responseNodeCount
                setAICaretPosition(getNotebookAICaretPosition(result.markdown, result.responseNodeIndex))
                return result.markdown
            })
        },
        [updateMarkdownEditorValue, enabledAIComponentTags]
    )

    const captureInlineAIFinished = useCallback(
        (request: InlineNotebookAIRequest, completion: InlineAICompletion): void => {
            // pinned: analytics event name and property names; renaming breaks dashboards
            posthog.capture(
                'notebook inline ai finished',
                buildNotebookInlineAIFinishedEvent(
                    request,
                    completion,
                    notebook?.short_id ?? shortId,
                    inlineAIRequestStartedAtRef.current[request.conversationId],
                    Date.now()
                )
            )
            delete inlineAIRequestStartedAtRef.current[request.conversationId]
        },
        [notebook?.short_id, shortId]
    )

    const handleInlineAIComplete = useCallback(
        (request: InlineNotebookAIRequest, completion: InlineAICompletion): void => {
            captureInlineAIFinished(request, completion)
            if (completion.kind !== 'assistant' && completion.kind !== 'artifact' && !completion.hasArtifact) {
                const replacedNodeCount = inlineAIResponseNodeCountsRef.current[request.conversationId] ?? 1
                updateMarkdownEditorValue((currentMarkdown) => {
                    const result = replaceNotebookAIResponseMarkdown(
                        currentMarkdown,
                        getInlineAIResponseNodeIndex(request, inlineAIResponseNodeIndicesRef.current),
                        completion.message,
                        replacedNodeCount,
                        enabledAIComponentTags
                    )
                    inlineAIResponseNodeIndicesRef.current[request.conversationId] = result.responseNodeIndex
                    setAICaretPosition(getNotebookAICaretPosition(result.markdown, result.responseNodeIndex))
                    return result.markdown
                })
                inlineAIResponseNodeCountsRef.current[request.conversationId] = getMarkdownBlockCount(
                    completion.message
                )
            }
            updateMarkdownEditorValue((currentMarkdown) =>
                insertNotebookAIFollowUpPromptAfterResponse(
                    currentMarkdown,
                    getInlineAIResponseNodeIndex(request, inlineAIResponseNodeIndicesRef.current),
                    NOTEBOOK_AI_FOLLOW_UP_PROMPT_MARKDOWN
                )
            )
            retainAIPresenceForPrompt()
            setFocusAIPromptRequest((currentRequest) => (currentRequest ?? 0) + 1)

            window.setTimeout(() => {
                delete inlineAIResponseNodeCountsRef.current[request.conversationId]
                delete inlineAIResponseNodeIndicesRef.current[request.conversationId]
                markAIPresenceInactive(request.conversationId)
                setInlineAIRequests((currentRequests) =>
                    currentRequests.filter((currentRequest) => currentRequest.conversationId !== request.conversationId)
                )
            }, 0)
        },
        [
            captureInlineAIFinished,
            markAIPresenceInactive,
            retainAIPresenceForPrompt,
            updateMarkdownEditorValue,
            enabledAIComponentTags,
        ]
    )

    const handleInlineAIError = useCallback(
        (request: InlineNotebookAIRequest, completion: InlineAICompletion): void => {
            captureInlineAIFinished(request, completion)
            const replacedNodeCount = inlineAIResponseNodeCountsRef.current[request.conversationId] ?? 1
            updateMarkdownEditorValue((currentMarkdown) => {
                const result = replaceNotebookAIResponseMarkdown(
                    currentMarkdown,
                    getInlineAIResponseNodeIndex(request, inlineAIResponseNodeIndicesRef.current),
                    completion.message,
                    replacedNodeCount,
                    enabledAIComponentTags
                )
                inlineAIResponseNodeIndicesRef.current[request.conversationId] = result.responseNodeIndex
                setAICaretPosition(getNotebookAICaretPosition(result.markdown, result.responseNodeIndex))
                return result.markdown
            })

            delete inlineAIResponseNodeCountsRef.current[request.conversationId]
            delete inlineAIResponseNodeIndicesRef.current[request.conversationId]
            markAIPresenceInactive(request.conversationId)
            setInlineAIRequests((currentRequests) =>
                currentRequests.filter((currentRequest) => currentRequest.conversationId !== request.conversationId)
            )
        },
        [captureInlineAIFinished, markAIPresenceInactive, updateMarkdownEditorValue, enabledAIComponentTags]
    )

    const aiWritingNodeIndexes = useMemo(
        () =>
            inlineAIRequests.map((request) =>
                getInlineAIResponseNodeIndex(request, inlineAIResponseNodeIndicesRef.current)
            ),
        [inlineAIRequests, markdownEditorValue]
    )

    return (
        <MarkdownNotebookRuntimeContext.Provider value={runtimeContext}>
            <NotebookBtwLayout session={btwSession} onClose={closeBtw}>
                <NotebookComponentRunStatusContext.Provider value={resolveComponentRunStatus}>
                    <MarkdownNotebook
                        value={markdownEditorValue}
                        aiPromptAuthorName={user?.first_name || 'You'}
                        remoteValue={remoteMarkdown}
                        remoteVersion={notebook?.version}
                        mode={isEditable ? 'edit' : 'view'}
                        hideResourceLinks={isShared}
                        registry={markdownRegistry}
                        extraInsertCommands={isEditable ? buildExtraInsertCommands : undefined}
                        hiddenInsertCommandKeys={hiddenInsertCommandKeys}
                        onChange={isEditable ? handleMarkdownNotebookChange : undefined}
                        onSaveRequested={isEditable ? saveNotebookNow : undefined}
                        onConflict={reportMarkdownMergeConflicts}
                        remoteCarets={remoteCarets}
                        onCaretChange={isEditable ? publishMarkdownCaret : undefined}
                        onAskAI={isEditable ? handleAskAI : undefined}
                        onBtw={isEditable ? openBtw : undefined}
                        convertExternalDataTransferToNodes={isEditable ? convertExternalDataTransferToNodes : undefined}
                        isAskAIDisabled={inlineAIRequests.length > 0}
                        askAIDisabledReason={
                            dataProcessingAccepted
                                ? undefined
                                : 'Approve AI data processing in organization settings to use Ask AI.'
                        }
                        createAIConversationId={uuid}
                        deferRemoteValue={markdownEditorInteractionActive}
                        onInteractionStateChange={setMarkdownEditorInteractionActive}
                        allowViewModeFilters={mountedNotebookLogic.props.mode === 'canvas'}
                        jupyterMode={jupyterMode}
                        canvasHeader={
                            jupyterMode ? (
                                <>
                                    {isEditable ? (
                                        <NotebookJupyterToolbar collapsedContainer={collapsedToolbarContainer} />
                                    ) : null}
                                    <NotebookVariablesBar />
                                </>
                            ) : (
                                <NotebookVariablesBar />
                            )
                        }
                        className="Notebook__markdown-v2"
                        data-attr="notebook-markdown-v2"
                        autoFocus={isEditable}
                        showDebug={isEditable}
                        debugOpen={isDebugOpen}
                        onDebugOpenChange={handleDebugOpenChange}
                        focusAIPromptRequest={focusAIPromptRequest}
                        aiWritingNodeIndexes={aiWritingNodeIndexes}
                    />
                </NotebookComponentRunStatusContext.Provider>
            </NotebookBtwLayout>
            {inlineAIRequests.map((request) => (
                <InlineNotebookAIRunner
                    key={request.conversationId}
                    request={request}
                    onComplete={handleInlineAIComplete}
                    onError={handleInlineAIError}
                    onAssistantMessage={handleInlineAIAssistantMessage}
                />
            ))}
            {isEditable ? (
                <MarkdownNotebookEntityPicker
                    action="add"
                    kind={openEntityPicker}
                    onClose={closeEntityPicker}
                    onSelect={insertPickedComponent}
                />
            ) : null}
        </MarkdownNotebookRuntimeContext.Provider>
    )
}

function getMarkdownBlockCount(markdown: string): number {
    return Math.max(1, parseMarkdownNotebook(markdown).nodes.length)
}

function getInlineAIResponseNodeIndex(
    request: InlineNotebookAIRequest,
    responseNodeIndices: Record<string, number>
): number {
    return responseNodeIndices[request.conversationId] ?? request.responseNodeIndex
}

export function getNotebookAICaretPosition(
    markdown: string,
    responseNodeIndex: number
): MarkdownNotebookCaretPosition | null {
    const nodes = parseMarkdownNotebook(markdown).nodes
    if (!nodes.length) {
        return null
    }

    const nodeIndex = Math.max(0, Math.min(responseNodeIndex, nodes.length - 1))
    return getNotebookNodeEndCaretPosition(nodes[nodeIndex], nodeIndex)
}

export function getNotebookAIPromptCaretPosition(markdown: string): MarkdownNotebookCaretPosition | null {
    const nodes = parseMarkdownNotebook(markdown).nodes
    for (let promptNodeIndex = nodes.length - 1; promptNodeIndex >= 0; promptNodeIndex--) {
        if (!isNotebookAIPromptNode(nodes[promptNodeIndex])) {
            continue
        }

        for (let nodeIndex = promptNodeIndex - 1; nodeIndex >= 0; nodeIndex--) {
            if (!isNotebookAIPromptNode(nodes[nodeIndex])) {
                return getNotebookNodeEndCaretPosition(nodes[nodeIndex], nodeIndex)
            }
        }
    }

    return null
}

function isNotebookAIPromptNode(node: NotebookBlockNode): boolean {
    return node.type === 'component' && node.tagName === 'Prompt'
}

function getNotebookNodeEndCaretPosition(node: NotebookBlockNode, nodeIndex: number): MarkdownNotebookCaretPosition {
    if (node.type === 'paragraph' || node.type === 'heading' || node.type === 'blockquote') {
        return { nodeIndex, offset: getInlineText(node.children).length }
    }
    if (node.type === 'code') {
        return { nodeIndex, offset: node.text.length }
    }
    if (node.type === 'list' && node.items.length > 0) {
        const listItemIndex = node.items.length - 1
        return {
            nodeIndex,
            listItemIndex,
            offset: getInlineText(node.items[listItemIndex].children).length,
        }
    }
    return { nodeIndex }
}