fix(agent): add conversation history context and sticky diff review bar

- Create context-aware message engine that includes prior conversation
  bubbles (user/assistant/tool calls) as history when sending messages
  to the LLM, fixing the missing multi-turn context issue.
- Fix diff review summary bar not sticking to the editor bottom by
  adding flex-column layout to the overlay container so sticky;bottom:0
  activates correctly.

Made-with: Cursor

Author: Innei

src/components/editor/rich/RichEditorWithAgent.tsx

@@ -1,5 +1,5 @@
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'
-import { createElement } from 'react'
+import { createElement, useMemo } from 'react'
 import { createRoot } from 'react-dom/client'
 import { $getRoot, $getState, $parseSerializedNode } from 'lexical'
 import {
@@ -54,6 +54,7 @@ import { API_URL } from '~/constants/env'
 import { useUIStore } from '~/stores/ui'
 
 import { AgentChatPanel } from './agent-chat/AgentChatPanel'
+import { createContextAwareEngine } from './agent-chat/composables/context-aware-engine'
 import { useAgentSetup } from './agent-chat/composables/use-agent-loop'
 import { useReapply } from './agent-chat/composables/use-agent-reapply'
 import { provideAgentStore } from './agent-chat/composables/use-agent-store'
@@ -163,7 +164,12 @@ function AgentLoopCaptureInner({
   provider: LLMProvider
   store: AgentStore
 }) {
-  const loop = useAgentLoop({ provider, store })
+  const messageEngine = useMemo(() => createContextAwareEngine(store), [store])
+  const loop = useAgentLoop({
+    provider,
+    store,
+    messageEngine: messageEngine as any,
+  })
   onAgentLoopReady(loop)
 
   const [editor] = useLexicalComposerContext()

src/components/editor/rich/agent-chat/composables/context-aware-engine.ts

@@ -0,0 +1,221 @@
+import type {
+  AgentStore,
+  ChatBubble,
+  ChatMessage,
+  MessageEngineContext,
+  PageContentContext,
+  PreparedMessages,
+  ToolCall,
+} from '@haklex/rich-agent-core'
+import type { SerializedEditorState } from 'lexical'
+
+import {
+  BaseLastUserContentProvider,
+  BaseSystemRoleProvider,
+  BaseSystemRootProvider,
+  buildDocumentContext,
+  MessagesEngine,
+} from '@haklex/rich-agent-core'
+import { defaultAgentSystemMessage } from '@haklex/rich-ext-ai-agent'
+
+const DOCUMENT_TOOL_SYSTEM_ROLE = `Use the document editing tools according to the following contract.
+
+## Document XML Contract
+
+- Document XML references use the serialized \`<doc>...</doc>\` structure.
+- Tool \`xml\` arguments must contain block fragments only, not a full \`<document>\` wrapper.
+- Use node IDs from injected XML context when a tool requires a target block.
+
+## Tool Contract
+
+### \`insert_node\`
+
+- Insert one or more block nodes.
+- \`position.type\` must be \`before\`, \`after\`, or \`root\`.
+- \`position.blockId\` is required for \`before\` and \`after\`.
+- \`xml\` must be valid block XML fragments.
+
+### \`replace_node\`
+
+- Replace the block identified by \`blockId\`.
+- The first block in \`xml\` replaces the target block.
+- Additional blocks, if any, are inserted after the replaced block.
+- Do not invent a new block ID inside replacement XML.
+
+### \`delete_node\`
+
+- Delete the block identified by \`blockId\`.
+- Use only when the user requests removal or the edit clearly requires deleting superseded content.
+
+### \`search_document\`
+
+- Use to locate candidate blocks by text or block type.
+- Prefer search when the target block is unknown or a prior edit attempt failed.
+
+## Failure Recovery
+
+- \`block_not_found\`: search again and retry with the correct target.
+- \`block_modified\`: assume the reference is stale; re-locate the target or narrow the edit.
+- \`xml_parse_error\`, \`invalid_xml\`, \`empty_xml\`: rewrite the XML as valid block fragments and retry.`
+
+class SystemRoleInjector extends BaseSystemRootProvider {
+  protected buildMessages() {
+    return [defaultAgentSystemMessage]
+  }
+}
+
+class ToolSystemRoleInjector extends BaseSystemRoleProvider {
+  protected buildContent() {
+    return DOCUMENT_TOOL_SYSTEM_ROLE
+  }
+}
+
+class PageEditorContextInjector extends BaseLastUserContentProvider {
+  protected buildContent(context: MessageEngineContext) {
+    const pageContext = resolvePageContentContext(context)
+    if (!pageContext) return null
+
+    const formatted = formatPageContentContext(pageContext)
+    if (!formatted) return null
+
+    return { content: formatted, contextType: 'current_page_context' }
+  }
+}
+
+function resolvePageContentContext(
+  context: MessageEngineContext,
+): PageContentContext | undefined {
+  if (context.pageContentContext) return context.pageContentContext
+
+  const initialPageEditor = context.initialContext?.pageEditor
+  if (!initialPageEditor) return undefined
+
+  return {
+    markdown: initialPageEditor.markdown,
+    metadata: initialPageEditor.metadata,
+    xml: context.stepContext?.stepPageEditor?.xml || initialPageEditor.xml,
+  }
+}
+
+function formatPageContentContext(context: PageContentContext): string {
+  const sections: string[] = []
+
+  if (context.markdown) {
+    const charCount = context.metadata.charCount ?? context.markdown.length
+    const lineCount =
+      context.metadata.lineCount ?? context.markdown.split('\n').length
+    sections.push(
+      `<markdown chars="${charCount}" lines="${lineCount}">\n${context.markdown}\n</markdown>`,
+    )
+  }
+
+  if (context.xml) {
+    sections.push(
+      `<doc_xml_structure>\n<instruction>IMPORTANT: Use node IDs from this XML structure when performing modify or remove operations.</instruction>\n${context.xml}\n</doc_xml_structure>`,
+    )
+  }
+
+  return `<current_page title="${context.metadata.title}">\n${sections.join('\n')}\n</current_page>`
+}
+
+/**
+ * Converts store ChatBubble[] to LLM ChatMessage[] for conversation history.
+ * Skips UI-only bubbles (thinking, error, diff_summary, diff_review).
+ */
+export function bubblesToChatMessages(bubbles: ChatBubble[]): ChatMessage[] {
+  const messages: ChatMessage[] = []
+
+  for (const bubble of bubbles) {
+    if (bubble.type === 'user') {
+      messages.push({ role: 'user', content: bubble.content })
+    } else if (
+      bubble.type === 'assistant' &&
+      bubble.content &&
+      !bubble.streaming
+    ) {
+      messages.push({ role: 'assistant', content: bubble.content })
+    } else if (bubble.type === 'tool_call_group') {
+      const toolCalls: ToolCall[] = []
+      for (const item of bubble.items) {
+        toolCalls.push({
+          id: item.id,
+          name: item.toolName,
+          arguments: JSON.stringify(item.params),
+        })
+      }
+
+      if (toolCalls.length > 0) {
+        messages.push({ role: 'assistant_tool_call', toolCalls })
+        for (const item of bubble.items) {
+          if (item.status === 'completed' || item.status === 'error') {
+            messages.push({
+              role: 'tool_result',
+              toolCallId: item.id,
+              content: item.result || item.error || '',
+              isError: item.status === 'error',
+            })
+          }
+        }
+      }
+    }
+  }
+
+  return messages
+}
+
+/**
+ * Creates a message engine that includes conversation history from the
+ * AgentStore when building messages for the LLM. This is a duck-typed
+ * replacement for AgentMessagesEngine with multi-turn support.
+ *
+ * The engine replicates the same processor pipeline as the library's
+ * AgentMessagesEngine (system role, tool docs, page context injection)
+ * but prepends conversation history from bubbles before the current
+ * user message.
+ */
+export function createContextAwareEngine(store: AgentStore) {
+  const engine = new MessagesEngine([
+    new SystemRoleInjector(),
+    new ToolSystemRoleInjector(),
+    new PageEditorContextInjector(),
+  ])
+
+  return {
+    processWithEditor(params: {
+      editorState: SerializedEditorState
+      userInput: string
+      title?: string
+    }): PreparedMessages {
+      const bubbles = store.getState().bubbles
+
+      // AgentChatPanel adds the user bubble to the store synchronously
+      // before emitting 'send', so the last bubble may be the current
+      // user message. Exclude it to avoid duplication (the engine creates
+      // its own user message below).
+      const lastBubble = bubbles[bubbles.length - 1]
+      const historyBubbles =
+        lastBubble?.type === 'user' && lastBubble.content === params.userInput
+          ? bubbles.slice(0, -1)
+          : bubbles
+
+      const history = bubblesToChatMessages(historyBubbles)
+
+      const userMessage: Extract<ChatMessage, { role: 'user' }> = {
+        role: 'user',
+        content: params.userInput,
+        cacheBreakpoint: true,
+      }
+
+      return engine.process({
+        messages: [...history, userMessage],
+        pageContentContext: {
+          metadata: { title: params.title ?? 'Current Document' },
+          xml: buildDocumentContext(params.editorState, {
+            mode: 'full',
+            compact: true,
+          }),
+        },
+      })
+    },
+  }
+}

src/components/editor/write-editor/index.css

@@ -171,3 +171,19 @@
 .write-editor-wrapper.rich-editor-mode.toolbar-stuck [role='toolbar'] {
   box-shadow: var(--rc-shadow-top-bar);
 }
+
+/* Diff review summary bar: stick to the bottom of the editor scroll viewport.
+   The overlay (_12dh7n0) is position:absolute;inset:0 covering the full content.
+   The bar (_12dh7n8) is position:sticky;bottom:0 (from the library).
+   Problem: sticky only activates when the element's natural position is past the
+   viewport edge. With no in-flow siblings, the bar sits at the overlay top.
+   Fix: flex-column + margin-top:auto pushes the bar to the content bottom,
+   so sticky;bottom:0 correctly pins it to the scroll viewport bottom. */
+.write-editor-wrapper.rich-editor-mode ._12dh7n0 {
+  display: flex;
+  flex-direction: column;
+}
+
+.write-editor-wrapper.rich-editor-mode ._12dh7n8 {
+  margin-top: auto;
+}