From cb05174f19a1be75c125012689d16c49e2b49331 Mon Sep 17 00:00:00 2001
From: Tony Giorgio <tonygiorgio@protonmail.com>
Date: Wed, 17 Dec 2025 18:14:02 -0600
Subject: [PATCH 1/6] Add Kimi K2 Thinking model and re-enable brain toggle

- Add kimi-k2-thinking to MODEL_CONFIG (256k context, Pro tier)
- Set Kimi K2 as reasoning_on model (with thinking)
- Keep DeepSeek R1 as reasoning_off model (without thinking)
- Re-enable brain toggle button in chat UI

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 frontend/src/components/ModelSelector.tsx |  11 +-
 frontend/src/components/UnifiedChat.tsx   | 132 +++++++++++-----------
 2 files changed, 73 insertions(+), 70 deletions(-)

diff --git a/frontend/src/components/ModelSelector.tsx b/frontend/src/components/ModelSelector.tsx
index 5000eea4..29dfd15f 100644
--- a/frontend/src/components/ModelSelector.tsx
+++ b/frontend/src/components/ModelSelector.tsx
@@ -68,6 +68,13 @@ export const MODEL_CONFIG: Record<string, ModelCfg> = {
     requiresPro: true,
     tokenLimit: 130000
   },
+  "kimi-k2-thinking": {
+    displayName: "Kimi K2 Thinking",
+    shortName: "Kimi K2",
+    badges: ["Pro", "Reasoning", "New"],
+    requiresPro: true,
+    tokenLimit: 256000
+  },
   "gpt-oss-120b": {
     displayName: "OpenAI GPT-OSS 120B",
     shortName: "GPT-OSS",
@@ -106,8 +113,8 @@ type ModelCategory = "free" | "quick" | "reasoning" | "math" | "image" | "advanc
 export const CATEGORY_MODELS = {
   free: "llama-3.3-70b",
   quick: "gpt-oss-120b",
-  reasoning_on: "deepseek-r1-0528", // R1 with thinking
-  reasoning_off: "deepseek-r1-0528", // R1 without thinking (brain toggle temporarily disabled)
+  reasoning_on: "kimi-k2-thinking", // Kimi K2 with thinking
+  reasoning_off: "deepseek-r1-0528", // DeepSeek R1 without thinking
   math: "qwen3-coder-480b",
   image: "qwen3-vl-30b" // Qwen3-VL for image analysis
 };
diff --git a/frontend/src/components/UnifiedChat.tsx b/frontend/src/components/UnifiedChat.tsx
index f72d8076..2d040f9e 100644
--- a/frontend/src/components/UnifiedChat.tsx
+++ b/frontend/src/components/UnifiedChat.tsx
@@ -2525,41 +2525,39 @@ export function UnifiedChat() {
                             }
                           />
 
-                          {/* Thinking toggle button - temporarily disabled while we remove V3.1 */}
-                          {/* eslint-disable-next-line no-constant-binary-expression */}
-                          {false &&
-                            (localState.model === CATEGORY_MODELS.reasoning_on ||
-                              localState.model === CATEGORY_MODELS.reasoning_off) && (
-                              <Button
-                                type="button"
-                                variant="ghost"
-                                size="sm"
-                                className="h-8 w-8 p-0"
-                                onClick={() => {
-                                  const newThinkingEnabled = !localState.thinkingEnabled;
-                                  localState.setThinkingEnabled(newThinkingEnabled);
-                                  // Switch between R1 (with thinking) and V3.1 (without)
-                                  localState.setModel(
-                                    newThinkingEnabled
-                                      ? CATEGORY_MODELS.reasoning_on
-                                      : CATEGORY_MODELS.reasoning_off
-                                  );
-                                }}
-                                aria-label={
+                          {/* Thinking toggle button - visible when reasoning model is selected */}
+                          {(localState.model === CATEGORY_MODELS.reasoning_on ||
+                            localState.model === CATEGORY_MODELS.reasoning_off) && (
+                            <Button
+                              type="button"
+                              variant="ghost"
+                              size="sm"
+                              className="h-8 w-8 p-0"
+                              onClick={() => {
+                                const newThinkingEnabled = !localState.thinkingEnabled;
+                                localState.setThinkingEnabled(newThinkingEnabled);
+                                // Switch between Kimi K2 (with thinking) and DeepSeek R1 (without)
+                                localState.setModel(
+                                  newThinkingEnabled
+                                    ? CATEGORY_MODELS.reasoning_on
+                                    : CATEGORY_MODELS.reasoning_off
+                                );
+                              }}
+                              aria-label={
+                                localState.thinkingEnabled
+                                  ? "Disable thinking mode"
+                                  : "Enable thinking mode"
+                              }
+                            >
+                              <Brain
+                                className={`h-4 w-4 ${
                                   localState.thinkingEnabled
-                                    ? "Disable thinking mode"
-                                    : "Enable thinking mode"
-                                }
-                              >
-                                <Brain
-                                  className={`h-4 w-4 ${
-                                    localState.thinkingEnabled
-                                      ? "text-purple-500"
-                                      : "text-muted-foreground"
-                                  }`}
-                                />
-                              </Button>
-                            )}
+                                    ? "text-purple-500"
+                                    : "text-muted-foreground"
+                                }`}
+                              />
+                            </Button>
+                          )}
 
                           {/* Web search toggle button - always visible */}
                           <Button
@@ -2804,41 +2802,39 @@ export function UnifiedChat() {
                           }
                         />
 
-                        {/* Thinking toggle button - temporarily disabled while we remove V3.1 */}
-                        {/* eslint-disable-next-line no-constant-binary-expression */}
-                        {false &&
-                          (localState.model === CATEGORY_MODELS.reasoning_on ||
-                            localState.model === CATEGORY_MODELS.reasoning_off) && (
-                            <Button
-                              type="button"
-                              variant="ghost"
-                              size="sm"
-                              className="h-8 w-8 p-0"
-                              onClick={() => {
-                                const newThinkingEnabled = !localState.thinkingEnabled;
-                                localState.setThinkingEnabled(newThinkingEnabled);
-                                // Switch between R1 (with thinking) and V3.1 (without)
-                                localState.setModel(
-                                  newThinkingEnabled
-                                    ? CATEGORY_MODELS.reasoning_on
-                                    : CATEGORY_MODELS.reasoning_off
-                                );
-                              }}
-                              aria-label={
+                        {/* Thinking toggle button - visible when reasoning model is selected */}
+                        {(localState.model === CATEGORY_MODELS.reasoning_on ||
+                          localState.model === CATEGORY_MODELS.reasoning_off) && (
+                          <Button
+                            type="button"
+                            variant="ghost"
+                            size="sm"
+                            className="h-8 w-8 p-0"
+                            onClick={() => {
+                              const newThinkingEnabled = !localState.thinkingEnabled;
+                              localState.setThinkingEnabled(newThinkingEnabled);
+                              // Switch between Kimi K2 (with thinking) and DeepSeek R1 (without)
+                              localState.setModel(
+                                newThinkingEnabled
+                                  ? CATEGORY_MODELS.reasoning_on
+                                  : CATEGORY_MODELS.reasoning_off
+                              );
+                            }}
+                            aria-label={
+                              localState.thinkingEnabled
+                                ? "Disable thinking mode"
+                                : "Enable thinking mode"
+                            }
+                          >
+                            <Brain
+                              className={`h-4 w-4 ${
                                 localState.thinkingEnabled
-                                  ? "Disable thinking mode"
-                                  : "Enable thinking mode"
-                              }
-                            >
-                              <Brain
-                                className={`h-4 w-4 ${
-                                  localState.thinkingEnabled
-                                    ? "text-purple-500"
-                                    : "text-muted-foreground"
-                                }`}
-                              />
-                            </Button>
-                          )}
+                                  ? "text-purple-500"
+                                  : "text-muted-foreground"
+                              }`}
+                            />
+                          </Button>
+                        )}
 
                         {/* Web search toggle button - always visible */}
                         <Button

From 0632d509598d0404f1c7f6dc0390f739f71b7264 Mon Sep 17 00:00:00 2001
From: Tony Giorgio <tonygiorgio@protonmail.com>
Date: Wed, 17 Dec 2025 19:54:25 -0600
Subject: [PATCH 2/6] Add support for reasoning_text streaming events

Handle response.reasoning_text.delta and response.reasoning_text.done events
for models like Kimi K2 that stream reasoning separately from content.
Reasoning is wrapped in <think> tags to reuse existing ThinkingBlock rendering.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 frontend/src/components/UnifiedChat.tsx | 67 ++++++++++++++++++++++++-
 1 file changed, 66 insertions(+), 1 deletion(-)

diff --git a/frontend/src/components/UnifiedChat.tsx b/frontend/src/components/UnifiedChat.tsx
index 2d040f9e..77f3350c 100644
--- a/frontend/src/components/UnifiedChat.tsx
+++ b/frontend/src/components/UnifiedChat.tsx
@@ -1652,6 +1652,7 @@ export function UnifiedChat() {
   const processStreamingResponse = useCallback(async (stream: AsyncIterable<unknown>) => {
     let serverAssistantId: string | undefined;
     let accumulatedContent = "";
+    let accumulatedReasoning = "";
 
     for await (const event of stream) {
       const eventType = (event as { type: string }).type;
@@ -1802,6 +1803,65 @@ export function UnifiedChat() {
             return withOutput;
           });
         }
+      } else if (
+        eventType === "response.reasoning_text.delta" &&
+        (event as { delta?: string }).delta
+      ) {
+        // Reasoning text delta - accumulate reasoning content (for models like Kimi K2)
+        const delta = (event as { delta: string }).delta;
+        accumulatedReasoning += delta;
+
+        if (serverAssistantId) {
+          setMessages((prev) => {
+            const msgToUpdate = prev.find((m) => m.id === serverAssistantId);
+            if (msgToUpdate && msgToUpdate.type === "message") {
+              const message = msgToUpdate as unknown as ExtendedMessage;
+              // Wrap reasoning in <think> tag (no closing tag while streaming)
+              const displayText = `<think>${accumulatedReasoning}`;
+              const outputContent: OutputTextContent = {
+                type: "output_text",
+                text: displayText,
+                annotations: []
+              };
+              const updated = {
+                ...message,
+                content: [outputContent],
+                status: "streaming" as const
+              } as unknown as Message;
+              return mergeMessagesById(prev, [updated]);
+            }
+            return prev;
+          });
+        }
+      } else if (eventType === "response.reasoning_text.done") {
+        // Reasoning completed - update with complete text and close think tag
+        const doneEvent = event as { text?: string };
+        if (doneEvent.text) {
+          accumulatedReasoning = doneEvent.text;
+        }
+
+        if (serverAssistantId) {
+          setMessages((prev) => {
+            const msgToUpdate = prev.find((m) => m.id === serverAssistantId);
+            if (msgToUpdate && msgToUpdate.type === "message") {
+              const message = msgToUpdate as unknown as ExtendedMessage;
+              // Close the think tag now that reasoning is done
+              const displayText = `<think>${accumulatedReasoning}</think>${accumulatedContent}`;
+              const outputContent: OutputTextContent = {
+                type: "output_text",
+                text: displayText,
+                annotations: []
+              };
+              const updated = {
+                ...message,
+                content: [outputContent],
+                status: "streaming" as const
+              } as unknown as Message;
+              return mergeMessagesById(prev, [updated]);
+            }
+            return prev;
+          });
+        }
       } else if (
         eventType === "response.output_text.delta" &&
         (event as { delta?: string }).delta
@@ -1815,9 +1875,14 @@ export function UnifiedChat() {
             const msgToUpdate = prev.find((m) => m.id === serverAssistantId);
             if (msgToUpdate && msgToUpdate.type === "message") {
               const message = msgToUpdate as unknown as ExtendedMessage;
+              // Prepend reasoning if exists (wrapped in think tags)
+              let displayText = accumulatedContent;
+              if (accumulatedReasoning) {
+                displayText = `<think>${accumulatedReasoning}</think>\n\n${accumulatedContent}`;
+              }
               const outputContent: OutputTextContent = {
                 type: "output_text",
-                text: accumulatedContent,
+                text: displayText,
                 annotations: []
               };
               const updated = {

From a043b93bd60a4d15a52f5fbbb9f1e61ba819bde9 Mon Sep 17 00:00:00 2001
From: Tony Giorgio <tonygiorgio@protonmail.com>
Date: Thu, 18 Dec 2025 08:50:29 -0600
Subject: [PATCH 3/6] Add reasoning item type for conversation items API

- Export ThinkingBlock from markdown.tsx for reuse
- Add ReasoningItem type to Message union for type: reasoning items
- Add rendering for reasoning items in MessageList using ThinkingBlock
- Handle response.output_item.added for reasoning items during streaming
- Update reasoning_text.delta/done handlers to update reasoning items
- Remove inline <think> tag wrapping from output_text.delta

Reasoning items are now proper conversation items that can be fetched
via the items API and are handled with the same dedup/paging logic
as messages and tool calls.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 frontend/src/components/UnifiedChat.tsx | 125 ++++++++++++++++--------
 frontend/src/components/markdown.tsx    |   4 +-
 2 files changed, 84 insertions(+), 45 deletions(-)

diff --git a/frontend/src/components/UnifiedChat.tsx b/frontend/src/components/UnifiedChat.tsx
index 77f3350c..cd8abde6 100644
--- a/frontend/src/components/UnifiedChat.tsx
+++ b/frontend/src/components/UnifiedChat.tsx
@@ -50,7 +50,7 @@ import { useIsMobile } from "@/utils/utils";
 import { fileToDataURL } from "@/utils/file";
 import { useOpenAI } from "@/ai/useOpenAi";
 import { DEFAULT_MODEL_ID } from "@/state/LocalStateContext";
-import { Markdown } from "@/components/markdown";
+import { Markdown, ThinkingBlock } from "@/components/markdown";
 import { ModelSelector, CATEGORY_MODELS } from "@/components/ModelSelector";
 import { useLocalState } from "@/state/useLocalState";
 import { useOpenSecret } from "@opensecret/react";
@@ -103,13 +103,24 @@ type ExtendedMessage = OpenAIMessage & {
   status?: "completed" | "in_progress" | "incomplete" | "streaming" | "error";
 };
 
-// Union type for all possible conversation items (messages, tool calls, tool outputs, web search)
+// Reasoning item type for model thinking/reasoning (e.g., Kimi K2)
+type ReasoningContentItem = { type: "text"; text: string };
+type ReasoningItem = {
+  type: "reasoning";
+  id: string;
+  content: ReasoningContentItem[];
+  status?: "completed" | "in_progress" | "incomplete" | "streaming";
+  created_at?: number;
+};
+
+// Union type for all possible conversation items (messages, tool calls, tool outputs, web search, reasoning)
 // This combines OpenAI's native types with response streaming types
 type Message =
   | ExtendedMessage
   | (ResponseFunctionWebSearch & { id: string })
   | (ResponseFunctionToolCall & { id: string })
-  | (ResponseFunctionToolCallOutputItem & { id: string });
+  | (ResponseFunctionToolCallOutputItem & { id: string })
+  | ReasoningItem;
 
 // Helper function to merge messages while ensuring uniqueness by ID
 // This prevents duplicate key warnings in React by deduplicating messages
@@ -459,6 +470,29 @@ const MessageList = memo(
             );
           }
 
+          // Reasoning item - render with ThinkingBlock (for models like Kimi K2)
+          if (itemType === "reasoning") {
+            const reasoning = item as ReasoningItem;
+            const text = reasoning.content
+              .filter((c) => c.type === "text")
+              .map((c) => c.text)
+              .join("");
+            const isThinking =
+              reasoning.status === "in_progress" || reasoning.status === "streaming";
+
+            return (
+              <div
+                key={item.id}
+                ref={index === 0 ? firstMessageRef : undefined}
+                className="py-2 px-4"
+              >
+                <div className="max-w-4xl mx-auto">
+                  <ThinkingBlock content={text} isThinking={isThinking} />
+                </div>
+              </div>
+            );
+          }
+
           // Regular message - render with role and content
           if (itemType === "message") {
             const message = item as unknown as ExtendedMessage;
@@ -1651,6 +1685,7 @@ export function UnifiedChat() {
   // Helper function to process streaming response - used by both initial request and retry
   const processStreamingResponse = useCallback(async (stream: AsyncIterable<unknown>) => {
     let serverAssistantId: string | undefined;
+    let serverReasoningId: string | undefined;
     let accumulatedContent = "";
     let accumulatedReasoning = "";
 
@@ -1699,6 +1734,24 @@ export function UnifiedChat() {
 
           setMessages((prev) => mergeMessagesById(prev, [webSearchItem]));
         }
+      } else if (
+        eventType === "response.output_item.added" &&
+        (event as { item?: { type?: string } }).item?.type === "reasoning"
+      ) {
+        // Reasoning item created - add immediately as a flat item (for models like Kimi K2)
+        const eventWithItem = event as { item?: { id?: string } };
+        if (eventWithItem.item?.id) {
+          serverReasoningId = eventWithItem.item.id;
+
+          const reasoningItem: ReasoningItem = {
+            id: serverReasoningId,
+            type: "reasoning",
+            content: [],
+            status: "in_progress"
+          };
+
+          setMessages((prev) => mergeMessagesById(prev, [reasoningItem]));
+        }
       } else if (eventType === "response.web_search_call.in_progress") {
         // Update web search status
         const webSearchEvent = event as { item_id?: string };
@@ -1807,56 +1860,47 @@ export function UnifiedChat() {
         eventType === "response.reasoning_text.delta" &&
         (event as { delta?: string }).delta
       ) {
-        // Reasoning text delta - accumulate reasoning content (for models like Kimi K2)
-        const delta = (event as { delta: string }).delta;
+        // Reasoning text delta - update the reasoning item (for models like Kimi K2)
+        const reasoningEvent = event as { delta: string; item_id?: string };
+        const delta = reasoningEvent.delta;
         accumulatedReasoning += delta;
 
-        if (serverAssistantId) {
+        // Use item_id from event if available, otherwise fall back to serverReasoningId
+        const reasoningId = reasoningEvent.item_id || serverReasoningId;
+
+        if (reasoningId) {
           setMessages((prev) => {
-            const msgToUpdate = prev.find((m) => m.id === serverAssistantId);
-            if (msgToUpdate && msgToUpdate.type === "message") {
-              const message = msgToUpdate as unknown as ExtendedMessage;
-              // Wrap reasoning in <think> tag (no closing tag while streaming)
-              const displayText = `<think>${accumulatedReasoning}`;
-              const outputContent: OutputTextContent = {
-                type: "output_text",
-                text: displayText,
-                annotations: []
+            const itemToUpdate = prev.find((m) => m.id === reasoningId);
+            if (itemToUpdate && itemToUpdate.type === "reasoning") {
+              const updated: ReasoningItem = {
+                ...(itemToUpdate as ReasoningItem),
+                content: [{ type: "text", text: accumulatedReasoning }],
+                status: "streaming"
               };
-              const updated = {
-                ...message,
-                content: [outputContent],
-                status: "streaming" as const
-              } as unknown as Message;
               return mergeMessagesById(prev, [updated]);
             }
             return prev;
           });
         }
       } else if (eventType === "response.reasoning_text.done") {
-        // Reasoning completed - update with complete text and close think tag
-        const doneEvent = event as { text?: string };
+        // Reasoning completed - finalize the reasoning item
+        const doneEvent = event as { text?: string; item_id?: string };
         if (doneEvent.text) {
           accumulatedReasoning = doneEvent.text;
         }
 
-        if (serverAssistantId) {
+        // Use item_id from event if available, otherwise fall back to serverReasoningId
+        const reasoningId = doneEvent.item_id || serverReasoningId;
+
+        if (reasoningId) {
           setMessages((prev) => {
-            const msgToUpdate = prev.find((m) => m.id === serverAssistantId);
-            if (msgToUpdate && msgToUpdate.type === "message") {
-              const message = msgToUpdate as unknown as ExtendedMessage;
-              // Close the think tag now that reasoning is done
-              const displayText = `<think>${accumulatedReasoning}</think>${accumulatedContent}`;
-              const outputContent: OutputTextContent = {
-                type: "output_text",
-                text: displayText,
-                annotations: []
+            const itemToUpdate = prev.find((m) => m.id === reasoningId);
+            if (itemToUpdate && itemToUpdate.type === "reasoning") {
+              const updated: ReasoningItem = {
+                ...(itemToUpdate as ReasoningItem),
+                content: [{ type: "text", text: accumulatedReasoning }],
+                status: "completed"
               };
-              const updated = {
-                ...message,
-                content: [outputContent],
-                status: "streaming" as const
-              } as unknown as Message;
               return mergeMessagesById(prev, [updated]);
             }
             return prev;
@@ -1875,14 +1919,9 @@ export function UnifiedChat() {
             const msgToUpdate = prev.find((m) => m.id === serverAssistantId);
             if (msgToUpdate && msgToUpdate.type === "message") {
               const message = msgToUpdate as unknown as ExtendedMessage;
-              // Prepend reasoning if exists (wrapped in think tags)
-              let displayText = accumulatedContent;
-              if (accumulatedReasoning) {
-                displayText = `<think>${accumulatedReasoning}</think>\n\n${accumulatedContent}`;
-              }
               const outputContent: OutputTextContent = {
                 type: "output_text",
-                text: displayText,
+                text: accumulatedContent,
                 annotations: []
               };
               const updated = {
diff --git a/frontend/src/components/markdown.tsx b/frontend/src/components/markdown.tsx
index 0b26154c..4fb72cda 100644
--- a/frontend/src/components/markdown.tsx
+++ b/frontend/src/components/markdown.tsx
@@ -22,13 +22,13 @@ async function copyToClipboard(text: string) {
   }
 }
 
-interface ThinkingBlockProps {
+export interface ThinkingBlockProps {
   content: string;
   isThinking: boolean;
   duration?: number;
 }
 
-function ThinkingBlock({ content, isThinking, duration }: ThinkingBlockProps) {
+export function ThinkingBlock({ content, isThinking, duration }: ThinkingBlockProps) {
   const [isExpanded, setIsExpanded] = useState(false);
   const [elapsedSeconds, setElapsedSeconds] = useState(0);
   const startTimeRef = useRef<number | null>(null);

From f33734e6c9d8d183f7547fe258d6c3ba9e7d6fcd Mon Sep 17 00:00:00 2001
From: Tony Giorgio <tonygiorgio@protonmail.com>
Date: Thu, 18 Dec 2025 09:33:41 -0600
Subject: [PATCH 4/6] Fix response.output_item.done to handle any item type

Update handler to use item.id from the event to mark the correct item
as completed, rather than only handling serverAssistantId. This properly
supports the separate reasoning and message items in the streaming flow.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 frontend/src/components/UnifiedChat.tsx | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/frontend/src/components/UnifiedChat.tsx b/frontend/src/components/UnifiedChat.tsx
index cd8abde6..7ccc223a 100644
--- a/frontend/src/components/UnifiedChat.tsx
+++ b/frontend/src/components/UnifiedChat.tsx
@@ -1935,8 +1935,26 @@ export function UnifiedChat() {
           });
         }
       } else if (eventType === "response.output_item.done") {
-        if (serverAssistantId) {
-          // Update status to completed
+        // Handle completion for any item type (reasoning, message, etc.)
+        const doneEvent = event as { item?: { id?: string; type?: string } };
+        const itemId = doneEvent.item?.id;
+
+        if (itemId) {
+          setMessages((prev) => {
+            const itemToUpdate = prev.find((m) => m.id === itemId);
+            if (itemToUpdate) {
+              const updated = {
+                ...itemToUpdate,
+                status: "completed"
+              } as unknown as Message;
+              return mergeMessagesById(prev, [updated]);
+            }
+            return prev;
+          });
+          // Update lastSeenItemId for polling (use the latest completed item)
+          setLastSeenItemId(itemId);
+        } else if (serverAssistantId) {
+          // Fallback to serverAssistantId if item.id not in event
           setMessages((prev) => {
             const msgToUpdate = prev.find((m) => m.id === serverAssistantId);
             if (msgToUpdate) {

From 6c06abd0f0c3a289945088dd68c87c621526ff36 Mon Sep 17 00:00:00 2001
From: Tony Giorgio <tonygiorgio@protonmail.com>
Date: Thu, 18 Dec 2025 10:04:04 -0600
Subject: [PATCH 5/6] Group assistant items into single Maple box

Refactor MessageList to group consecutive assistant items (reasoning,
tool calls, message content) into a single 'Maple' box instead of
rendering them separately. This provides a cleaner UI similar to how
DeepSeek's <think> tags rendered inline.

Changes:
- Add MessageGroup type for user/assistant turn grouping
- Group messages using useMemo before rendering
- Render all assistant items within one Maple wrapper
- Fix loading indicator to not show duplicate box during tool use
- Export ThinkingBlock from markdown.tsx for reuse

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 frontend/src/components/UnifiedChat.tsx | 453 +++++++++++++++---------
 1 file changed, 287 insertions(+), 166 deletions(-)

diff --git a/frontend/src/components/UnifiedChat.tsx b/frontend/src/components/UnifiedChat.tsx
index 7ccc223a..7ee2c5ba 100644
--- a/frontend/src/components/UnifiedChat.tsx
+++ b/frontend/src/components/UnifiedChat.tsx
@@ -361,6 +361,11 @@ function ToolCallRenderer({
   return null;
 }
 
+// Types for grouping messages into turns
+type MessageGroup =
+  | { type: "user"; message: ExtendedMessage; id: string }
+  | { type: "assistant"; items: Message[]; id: string };
+
 // Memoized message list component to prevent re-renders on input changes
 const MessageList = memo(
   ({
@@ -377,7 +382,6 @@ const MessageList = memo(
     isLoadingOlderMessages?: boolean;
   }) => {
     // Build Maps for O(1) lookup of tool calls and outputs by call_id
-    // This handles out-of-order tool calls/outputs (e.g., parallel tool execution)
     const { callMap, outputMap } = useMemo(() => {
       const calls = new Map<string, Message>();
       const outputs = new Map<string, Message>();
@@ -393,6 +397,191 @@ const MessageList = memo(
       return { callMap: calls, outputMap: outputs };
     }, [messages]);
 
+    // Group messages into user turns and assistant turns
+    // Assistant turns include: reasoning, tool calls, tool outputs, web search, and assistant messages
+    const groupedMessages = useMemo(() => {
+      const groups: MessageGroup[] = [];
+      let currentAssistantItems: Message[] = [];
+
+      for (const item of messages) {
+        // Check if this is a user message
+        if (item.type === "message" && (item as unknown as ExtendedMessage).role === "user") {
+          // Flush any pending assistant items first
+          if (currentAssistantItems.length > 0) {
+            groups.push({
+              type: "assistant",
+              items: currentAssistantItems,
+              id: `assistant-${currentAssistantItems[0].id}`
+            });
+            currentAssistantItems = [];
+          }
+          groups.push({
+            type: "user",
+            message: item as unknown as ExtendedMessage,
+            id: item.id
+          });
+        } else {
+          // This is an assistant-related item (reasoning, tool calls, assistant message, etc.)
+          currentAssistantItems.push(item);
+        }
+      }
+
+      // Don't forget trailing assistant items
+      if (currentAssistantItems.length > 0) {
+        groups.push({
+          type: "assistant",
+          items: currentAssistantItems,
+          id: `assistant-${currentAssistantItems[0].id}`
+        });
+      }
+
+      return groups;
+    }, [messages]);
+
+    // Helper to render an individual item within an assistant group
+    const renderAssistantItem = (item: Message) => {
+      const itemType = item.type;
+
+      // Tool calls - render with pairing
+      if (itemType === "function_call") {
+        const toolCall = item as unknown as ResponseFunctionToolCall;
+        const output = outputMap.get(toolCall.call_id) as
+          | ResponseFunctionToolCallOutputItem
+          | undefined;
+
+        return (
+          <div key={item.id} className="mb-2">
+            <ToolCallRenderer tool={toolCall} toolOutput={output} />
+          </div>
+        );
+      }
+
+      // Tool outputs - skip if already rendered with call
+      if (itemType === "function_call_output") {
+        const output = item as unknown as ResponseFunctionToolCallOutputItem;
+        const matchingCall = callMap.get(output.call_id);
+
+        if (matchingCall) {
+          return null; // Already rendered with the call
+        }
+        return (
+          <div key={item.id} className="mb-2">
+            <ToolCallRenderer tool={output} />
+          </div>
+        );
+      }
+
+      // Web search
+      if (itemType === "web_search_call") {
+        const webSearch = item as unknown as ResponseFunctionWebSearch;
+        return (
+          <div key={item.id} className="mb-2">
+            <ToolCallRenderer tool={webSearch} />
+          </div>
+        );
+      }
+
+      // Reasoning - render with ThinkingBlock
+      if (itemType === "reasoning") {
+        const reasoning = item as ReasoningItem;
+        const text = reasoning.content
+          .filter((c) => c.type === "text")
+          .map((c) => c.text)
+          .join("");
+        const isThinking = reasoning.status === "in_progress" || reasoning.status === "streaming";
+
+        return (
+          <div key={item.id} className="mb-2">
+            <ThinkingBlock content={text} isThinking={isThinking} />
+          </div>
+        );
+      }
+
+      // Assistant message content
+      if (itemType === "message") {
+        const message = item as unknown as ExtendedMessage;
+        if (message.role !== "assistant") return null;
+
+        const isAssistantLoading = message.status === "in_progress";
+        if ((!message.content || message.content.length === 0) && !isAssistantLoading) {
+          return null;
+        }
+
+        return (
+          <div key={item.id}>
+            <div className="prose prose-sm dark:prose-invert max-w-none">
+              <div className="space-y-3">
+                {message.content?.map((part, partIdx) => {
+                  if (
+                    (part.type === "input_text" ||
+                      part.type === "output_text" ||
+                      part.type === "text") &&
+                    "text" in part &&
+                    part.text
+                  ) {
+                    return (
+                      <div key={partIdx}>
+                        <Markdown
+                          content={part.text}
+                          loading={(message as { status?: string }).status === "streaming"}
+                          chatId={chatId || ""}
+                        />
+                      </div>
+                    );
+                  }
+                  if (part.type === "input_image" && "image_url" in part && part.image_url) {
+                    return (
+                      <div key={partIdx}>
+                        <img
+                          src={part.image_url}
+                          alt={`Image ${partIdx + 1}`}
+                          className="max-w-full rounded-lg"
+                          style={{ maxHeight: "400px", objectFit: "contain" }}
+                        />
+                      </div>
+                    );
+                  }
+                  return null;
+                })}
+              </div>
+            </div>
+
+            {/* Status indicators */}
+            {message.status === "in_progress" && (
+              <div className="flex items-center gap-1 text-muted-foreground mt-2">
+                <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse" />
+                <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse delay-75" />
+                <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse delay-150" />
+              </div>
+            )}
+            {message.status === "incomplete" && (
+              <div className="inline-flex items-center gap-2 text-sm text-muted-foreground bg-muted/50 px-3 py-1.5 rounded-md mt-2">
+                <div className="w-1.5 h-1.5 rounded-full bg-yellow-500" />
+                <span>Chat Canceled</span>
+              </div>
+            )}
+          </div>
+        );
+      }
+
+      return null;
+    };
+
+    // Get all text content from an assistant group for the copy button
+    const getAssistantGroupText = (items: Message[]) => {
+      return items
+        .filter((item) => item.type === "message")
+        .flatMap((item) => {
+          const message = item as unknown as ExtendedMessage;
+          return (
+            message.content
+              ?.filter((p) => "text" in p && p.text)
+              .map((p) => ("text" in p ? p.text : "")) || []
+          );
+        })
+        .join("");
+    };
+
     return (
       <>
         {/* Loading indicator for older messages */}
@@ -406,130 +595,29 @@ const MessageList = memo(
           </div>
         )}
 
-        {messages.map((item, index) => {
-          // Handle different item types - messages, tool calls, tool outputs
-          const itemType = item.type;
-
-          // Tool calls and outputs - render as standalone items with pairing
-          if (itemType === "function_call") {
-            const toolCall = item as unknown as ResponseFunctionToolCall;
-            // Look up matching output by call_id (handles out-of-order arrival)
-            const output = outputMap.get(toolCall.call_id) as
-              | ResponseFunctionToolCallOutputItem
-              | undefined;
-
-            return (
-              <div
-                key={item.id}
-                ref={index === 0 ? firstMessageRef : undefined}
-                className="py-2 px-4"
-              >
-                <div className="max-w-4xl mx-auto">
-                  <ToolCallRenderer tool={toolCall} toolOutput={output} />
-                </div>
-              </div>
-            );
-          }
-
-          if (itemType === "function_call_output") {
-            const output = item as unknown as ResponseFunctionToolCallOutputItem;
-            // Check if matching call exists (handles out-of-order arrival)
-            const matchingCall = callMap.get(output.call_id);
-
-            if (matchingCall) {
-              // Already rendered with the call, skip
-              return null;
-            } else {
-              // Orphan output (call hasn't arrived yet), render standalone
-              return (
-                <div
-                  key={item.id}
-                  ref={index === 0 ? firstMessageRef : undefined}
-                  className="py-2 px-4"
-                >
-                  <div className="max-w-4xl mx-auto">
-                    <ToolCallRenderer tool={output} />
-                  </div>
-                </div>
-              );
-            }
-          }
-
-          if (itemType === "web_search_call") {
-            const webSearch = item as unknown as ResponseFunctionWebSearch;
-            return (
-              <div
-                key={item.id}
-                ref={index === 0 ? firstMessageRef : undefined}
-                className="py-2 px-4"
-              >
-                <div className="max-w-4xl mx-auto">
-                  <ToolCallRenderer tool={webSearch} />
-                </div>
-              </div>
-            );
-          }
-
-          // Reasoning item - render with ThinkingBlock (for models like Kimi K2)
-          if (itemType === "reasoning") {
-            const reasoning = item as ReasoningItem;
-            const text = reasoning.content
-              .filter((c) => c.type === "text")
-              .map((c) => c.text)
-              .join("");
-            const isThinking =
-              reasoning.status === "in_progress" || reasoning.status === "streaming";
+        {groupedMessages.map((group, groupIndex) => {
+          if (group.type === "user") {
+            const message = group.message;
+            if (!message.content || message.content.length === 0) return null;
 
             return (
               <div
-                key={item.id}
-                ref={index === 0 ? firstMessageRef : undefined}
-                className="py-2 px-4"
-              >
-                <div className="max-w-4xl mx-auto">
-                  <ThinkingBlock content={text} isThinking={isThinking} />
-                </div>
-              </div>
-            );
-          }
-
-          // Regular message - render with role and content
-          if (itemType === "message") {
-            const message = item as unknown as ExtendedMessage;
-            // Skip if no content, UNLESS it's an assistant message with in_progress status
-            // (we want to show the three-dot loading indicator for those)
-            const isAssistantLoading =
-              message.role === "assistant" && message.status === "in_progress";
-            if ((!message.content || message.content.length === 0) && !isAssistantLoading)
-              return null;
-
-            return (
-              <div
-                key={message.id}
-                ref={index === 0 ? firstMessageRef : undefined}
-                className={`group py-6 px-4 ${message.role === "user" ? "bg-muted/30" : ""}`}
+                key={group.id}
+                ref={groupIndex === 0 ? firstMessageRef : undefined}
+                className="group py-6 px-4 bg-muted/30"
               >
                 <div className="flex flex-col md:flex-row gap-3 max-w-4xl mx-auto">
                   <div className="flex-shrink-0">
-                    {message.role === "user" ? (
-                      <div className="w-8 h-8 rounded-full bg-primary/10 flex items-center justify-center">
-                        <User className="h-4 w-4 text-primary" />
-                      </div>
-                    ) : (
-                      <div className="w-8 h-8 rounded-full bg-primary/10 flex items-center justify-center">
-                        <Bot className="h-4 w-4 text-primary" />
-                      </div>
-                    )}
+                    <div className="w-8 h-8 rounded-full bg-primary/10 flex items-center justify-center">
+                      <User className="h-4 w-4 text-primary" />
+                    </div>
                   </div>
                   <div className="flex-1 overflow-hidden w-full md:w-auto">
                     <div className="space-y-2">
-                      <div className="font-semibold text-sm">
-                        {message.role === "user" ? "You" : "Maple"}
-                      </div>
+                      <div className="font-semibold text-sm">You</div>
                       <div className="prose prose-sm dark:prose-invert max-w-none">
                         <div className="space-y-3">
                           {message.content.map((part, partIdx) => {
-                            // Text content
                             if (
                               (part.type === "input_text" ||
                                 part.type === "output_text" ||
@@ -539,18 +627,11 @@ const MessageList = memo(
                             ) {
                               return (
                                 <div key={partIdx}>
-                                  <Markdown
-                                    content={part.text}
-                                    loading={
-                                      (message as { status?: string }).status === "streaming"
-                                    }
-                                    chatId={chatId || ""}
-                                  />
+                                  <Markdown content={part.text} chatId={chatId || ""} />
                                 </div>
                               );
                             }
-                            // Image content
-                            else if (
+                            if (
                               part.type === "input_image" &&
                               "image_url" in part &&
                               part.image_url
@@ -570,35 +651,52 @@ const MessageList = memo(
                           })}
                         </div>
                       </div>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            );
+          }
 
-                      {/* Status indicators */}
-                      {message.role === "assistant" && message.status === "in_progress" && (
-                        <div className="flex items-center gap-1 text-muted-foreground">
-                          <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse" />
-                          <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse delay-75" />
-                          <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse delay-150" />
-                        </div>
-                      )}
-                      {message.role === "assistant" && message.status === "incomplete" && (
-                        <div className="inline-flex items-center gap-2 text-sm text-muted-foreground bg-muted/50 px-3 py-1.5 rounded-md mt-2">
-                          <div className="w-1.5 h-1.5 rounded-full bg-yellow-500" />
-                          <span>Chat Canceled</span>
+          // Assistant group - render all items in one Maple box
+          if (group.type === "assistant") {
+            const hasContent = group.items.some((item) => {
+              if (item.type === "message") {
+                const msg = item as unknown as ExtendedMessage;
+                return (
+                  msg.role === "assistant" &&
+                  (msg.content?.length > 0 || msg.status === "in_progress")
+                );
+              }
+              return true; // reasoning, tool calls always count
+            });
+
+            if (!hasContent) return null;
+
+            const textContent = getAssistantGroupText(group.items);
+
+            return (
+              <div
+                key={group.id}
+                ref={groupIndex === 0 ? firstMessageRef : undefined}
+                className="group py-6 px-4"
+              >
+                <div className="flex flex-col md:flex-row gap-3 max-w-4xl mx-auto">
+                  <div className="flex-shrink-0">
+                    <div className="w-8 h-8 rounded-full bg-primary/10 flex items-center justify-center">
+                      <Bot className="h-4 w-4 text-primary" />
+                    </div>
+                  </div>
+                  <div className="flex-1 overflow-hidden w-full md:w-auto">
+                    <div className="space-y-2">
+                      <div className="font-semibold text-sm">Maple</div>
+                      {group.items.map((item) => renderAssistantItem(item))}
+                      {/* Copy button for the assistant's text content */}
+                      {textContent && (
+                        <div className="flex gap-1 md:opacity-0 md:group-hover:opacity-100 transition-opacity">
+                          <CopyButton text={textContent} />
                         </div>
                       )}
-
-                      {/* Actions - always visible on mobile, show on hover for desktop */}
-                      {message.role === "assistant" &&
-                        message.content &&
-                        message.content.length > 0 && (
-                          <div className="flex gap-1 md:opacity-0 md:group-hover:opacity-100 transition-opacity">
-                            <CopyButton
-                              text={message.content
-                                .filter((p) => "text" in p && p.text)
-                                .map((p) => ("text" in p ? p.text : ""))
-                                .join("")}
-                            />
-                          </div>
-                        )}
                     </div>
                   </div>
                 </div>
@@ -606,37 +704,60 @@ const MessageList = memo(
             );
           }
 
-          // Unknown item type
           return null;
         })}
 
         {/* Loading indicator - modern style */}
-        {isGenerating &&
-          !messages.some(
+        {/* Only show when generating AND no assistant content is being rendered */}
+        {(() => {
+          // Check if the last item is tool-related (means we're in tool phase, already rendering in Maple box)
+          const lastItem = messages[messages.length - 1];
+          const isLastItemToolRelated =
+            lastItem &&
+            (lastItem.type === "function_call" ||
+              lastItem.type === "function_call_output" ||
+              lastItem.type === "web_search_call");
+
+          const hasStreamingAssistant = messages.some(
             (item) =>
               item.type === "message" &&
               (item as unknown as ExtendedMessage).role === "assistant" &&
               ((item as { status?: string }).status === "streaming" ||
                 (item as { status?: string }).status === "in_progress")
-          ) && (
-            <div className="group py-6 px-4">
-              <div className="flex gap-3 max-w-4xl mx-auto">
-                <div className="flex-shrink-0">
-                  <div className="w-8 h-8 rounded-full bg-primary/10 flex items-center justify-center">
-                    <Bot className="h-4 w-4 text-primary" />
-                  </div>
+          );
+
+          const hasStreamingReasoning = messages.some(
+            (item) =>
+              item.type === "reasoning" &&
+              ((item as { status?: string }).status === "streaming" ||
+                (item as { status?: string }).status === "in_progress")
+          );
+
+          return (
+            isGenerating &&
+            !hasStreamingAssistant &&
+            !hasStreamingReasoning &&
+            !isLastItemToolRelated
+          );
+        })() && (
+          <div className="group py-6 px-4">
+            <div className="flex gap-3 max-w-4xl mx-auto">
+              <div className="flex-shrink-0">
+                <div className="w-8 h-8 rounded-full bg-primary/10 flex items-center justify-center">
+                  <Bot className="h-4 w-4 text-primary" />
                 </div>
-                <div className="flex-1 space-y-2">
-                  <div className="font-semibold text-sm">Maple</div>
-                  <div className="flex items-center gap-1">
-                    <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse" />
-                    <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse delay-75" />
-                    <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse delay-150" />
-                  </div>
+              </div>
+              <div className="flex-1 space-y-2">
+                <div className="font-semibold text-sm">Maple</div>
+                <div className="flex items-center gap-1">
+                  <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse" />
+                  <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse delay-75" />
+                  <div className="w-2 h-2 bg-foreground/60 rounded-full animate-pulse delay-150" />
                 </div>
               </div>
             </div>
-          )}
+          </div>
+        )}
       </>
     );
   }

From e6a20f15a720e3b3b4163b431cd8e84a265dfca9 Mon Sep 17 00:00:00 2001
From: Tony Giorgio <tonygiorgio@protonmail.com>
Date: Fri, 19 Dec 2025 11:47:13 -0600
Subject: [PATCH 6/6] Add Kimi K2 to marketing page

- Add Kimi logo (badge-kimi-logo.png)
- Add Kimi K2 to AI_MODELS array
- Change grid to 3 columns for balanced 2-row layout

Closes #345

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 frontend/public/badge-kimi-logo.png   | Bin 0 -> 11289 bytes
 frontend/src/components/Marketing.tsx |   7 ++++++-
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 frontend/public/badge-kimi-logo.png

diff --git a/frontend/public/badge-kimi-logo.png b/frontend/public/badge-kimi-logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..f8602db9c6eb5c88310dd808004a0aed3690fcf2
GIT binary patch
literal 11289
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
XKfw77Qat>V{6gfVm7rykMnV4rE6w~r

literal 0
HcmV?d00001

diff --git a/frontend/src/components/Marketing.tsx b/frontend/src/components/Marketing.tsx
index 07d93f37..f0358b13 100644
--- a/frontend/src/components/Marketing.tsx
+++ b/frontend/src/components/Marketing.tsx
@@ -27,6 +27,11 @@ const AI_MODELS = [
     alt: "DeepSeek",
     labels: ["DeepSeek R1"]
   },
+  {
+    src: "/badge-kimi-logo.png",
+    alt: "Moonshot",
+    labels: ["Kimi K2"]
+  },
   { src: "/badge-qwen-logo.png", alt: "Qwen", labels: ["Qwen3 Coder", "Qwen3-VL"] },
   { src: "/badge-meta-logo.png", alt: "Meta", labels: ["Meta Llama"] }
 ];
@@ -428,7 +433,7 @@ export function Marketing() {
               We use full-size open models from the biggest providers.
             </p>
           </div>
-          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-5 gap-8">
+          <div className="grid grid-cols-2 md:grid-cols-3 gap-8">
             {AI_MODELS.map((model) => (
               <div key={model.alt} className="flex flex-col items-center">
                 <img