@optilogic/chat 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/index.js

@@ -1,15 +1,36 @@
-import * as React from 'react';
-import { useState, useCallback, useMemo, useEffect } from 'react';
-import { cn, Popover, PopoverTrigger, PopoverContent, LoadingSpinner } from '@optilogic/core';
-import { Wrench, Book, HardDrive, Check, Copy, ThumbsUp, ThumbsDown, ChevronUp, ChevronDown } from 'lucide-react';
+import * as React11 from 'react';
+import { useState, useCallback, useRef, useEffect, useMemo } from 'react';
+import { cn, Popover, PopoverTrigger, PopoverContent, Button, Textarea, IconButton, LoadingSpinner } from '@optilogic/core';
+import { Activity, Wrench, Book, HardDrive, Check, Copy, ThumbsUp, ThumbsDown, ChevronDown, ChevronRight, MessageCircleQuestion, Square, Loader2, Send, ChevronUp, Brain, BookOpen, MessageSquare, AlertCircle, ChevronsDownUp, ChevronsUpDown } from 'lucide-react';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { SlateEditor, Text } from '@optilogic/editor';
 
 // src/components/agent-response/AgentResponse.tsx
-var ActivityIndicators = React.forwardRef(
-  ({ toolCalls, knowledge, memory, className, ...props }, ref) => {
-    const hasAnyActivity = toolCalls.length > 0 || knowledge.length > 0 || memory.length > 0;
+var ActivityIndicators = React11.forwardRef(
+  ({ toolCalls, knowledge, memory, statusUpdates = [], className, ...props }, ref) => {
+    const hasAnyActivity = toolCalls.length > 0 || knowledge.length > 0 || memory.length > 0 || statusUpdates.length > 0;
     if (!hasAnyActivity) return null;
     return /* @__PURE__ */ jsxs("div", { ref, className: cn("flex items-center gap-2", className), ...props, children: [
+      statusUpdates.length > 0 && /* @__PURE__ */ jsxs(Popover, { children: [
+        /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+          "button",
+          {
+            className: "flex items-center gap-1 text-muted-foreground hover:text-foreground transition-colors",
+            onClick: (e) => e.stopPropagation(),
+            children: [
+              /* @__PURE__ */ jsx(Activity, { className: "w-3.5 h-3.5" }),
+              /* @__PURE__ */ jsx("span", { className: "text-xs", children: statusUpdates.length })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsx(PopoverContent, { className: "w-80", children: /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx("h4", { className: "font-medium text-sm", children: "Status Updates" }),
+          /* @__PURE__ */ jsx("div", { className: "space-y-2 max-h-60 overflow-auto", children: statusUpdates.map((item) => /* @__PURE__ */ jsxs("div", { className: "p-2 bg-muted rounded text-xs", children: [
+            item.agent && /* @__PURE__ */ jsx("div", { className: "font-medium text-muted-foreground", children: item.agent }),
+            /* @__PURE__ */ jsx("div", { className: item.agent ? "mt-1" : "", children: item.message })
+          ] }, item.id)) })
+        ] }) })
+      ] }),
       toolCalls.length > 0 && /* @__PURE__ */ jsxs(Popover, { children: [
         /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
           "button",
@@ -104,7 +125,7 @@ function formatTotalTime(seconds) {
   const minutes = seconds / 60;
   return `${minutes.toFixed(1)}m`;
 }
-var MetadataRow = React.forwardRef(
+var MetadataRow = React11.forwardRef(
   ({
     hasThinking,
     isExpanded,
@@ -112,6 +133,8 @@ var MetadataRow = React.forwardRef(
     toolCalls,
     knowledge,
     memory,
+    statusUpdates = [],
+    statusContent,
     status,
     elapsedTime,
     className,
@@ -119,7 +142,7 @@ var MetadataRow = React.forwardRef(
   }, ref) => {
     const isProcessing = status === "processing";
     const isComplete = status === "complete";
-    const hasActivity = toolCalls.length > 0 || knowledge.length > 0 || memory.length > 0;
+    const hasActivity = toolCalls.length > 0 || knowledge.length > 0 || memory.length > 0 || statusUpdates.length > 0;
     const renderLeftContent = () => {
       if (hasThinking) {
         return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
@@ -136,7 +159,7 @@ var MetadataRow = React.forwardRef(
       return null;
     };
     const leftContent = renderLeftContent();
-    if (!leftContent && !hasActivity) {
+    if (!leftContent && !hasActivity && !statusContent) {
       return null;
     }
     return /* @__PURE__ */ jsxs(
@@ -150,16 +173,18 @@ var MetadataRow = React.forwardRef(
             "button",
             {
               onClick: onToggle,
-              className: "flex items-center gap-1.5 hover:bg-muted/50 -ml-1.5 pl-1.5 pr-2 py-0.5 rounded transition-colors",
+              className: "flex items-center gap-1.5 hover:bg-muted/50 -ml-1.5 pl-1.5 pr-2 py-0.5 rounded transition-colors shrink-0",
               children: leftContent
             }
-          ) : /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1.5", children: leftContent }),
+          ) : /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1.5 shrink-0", children: leftContent }),
+          statusContent && /* @__PURE__ */ jsx("div", { className: "flex-1 min-w-0 mx-2", children: statusContent }),
           /* @__PURE__ */ jsx(
             ActivityIndicators,
             {
               toolCalls,
               knowledge,
-              memory
+              memory,
+              statusUpdates
             }
           )
         ]
@@ -168,24 +193,61 @@ var MetadataRow = React.forwardRef(
   }
 );
 MetadataRow.displayName = "MetadataRow";
-var ThinkingSection = React.forwardRef(
-  ({ content, isExpanded, className, ...props }, ref) => {
-    if (!isExpanded || !content) {
+var ThinkingStepItem = ({ step, renderMarkdown }) => {
+  const [isCollapsed, setIsCollapsed] = useState(step.isCollapsed ?? false);
+  const toggleCollapse = useCallback(() => {
+    setIsCollapsed((prev) => !prev);
+  }, []);
+  const indentPadding = step.depth * 16;
+  return /* @__PURE__ */ jsxs("div", { className: "border-b border-border/50 last:border-b-0", children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: toggleCollapse,
+        className: "w-full flex items-center gap-1.5 py-1.5 px-2 hover:bg-muted/50 transition-colors text-left",
+        style: { paddingLeft: `${indentPadding + 8}px` },
+        children: [
+          isCollapsed ? /* @__PURE__ */ jsx(ChevronRight, { className: "w-3 h-3 text-muted-foreground flex-shrink-0" }) : /* @__PURE__ */ jsx(ChevronDown, { className: "w-3 h-3 text-muted-foreground flex-shrink-0" }),
+          /* @__PURE__ */ jsx("span", { className: "text-xs font-medium text-foreground/80", children: step.label })
+        ]
+      }
+    ),
+    !isCollapsed && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "pb-2 px-2",
+        style: { paddingLeft: `${indentPadding + 28}px` },
+        children: renderMarkdown ? /* @__PURE__ */ jsx("div", { className: "text-xs text-muted-foreground", children: renderMarkdown(step.content) }) : /* @__PURE__ */ jsx("pre", { className: "text-xs text-muted-foreground whitespace-pre-wrap font-mono", children: step.content })
+      }
+    )
+  ] });
+};
+var ThinkingSection = React11.forwardRef(
+  ({ content, isExpanded, renderMarkdown, className, ...props }, ref) => {
+    if (!isExpanded || !content || Array.isArray(content) && content.length === 0) {
       return null;
     }
+    const isStructured = Array.isArray(content);
     return /* @__PURE__ */ jsx(
       "div",
       {
         ref,
         className: cn("px-3 pb-3 border-t border-border", className),
         ...props,
-        children: /* @__PURE__ */ jsx("div", { className: "mt-2 max-h-[200px] overflow-y-auto", children: /* @__PURE__ */ jsx("pre", { className: "text-xs text-muted-foreground whitespace-pre-wrap font-mono", children: content }) })
+        children: /* @__PURE__ */ jsx("div", { className: "mt-2 max-h-[200px] overflow-y-auto scrollbar-thin", children: isStructured ? /* @__PURE__ */ jsx("div", { className: "space-y-0", children: content.map((step) => /* @__PURE__ */ jsx(
+          ThinkingStepItem,
+          {
+            step,
+            renderMarkdown
+          },
+          step.id
+        )) }) : renderMarkdown ? /* @__PURE__ */ jsx("div", { className: "text-xs text-muted-foreground", children: renderMarkdown(content) }) : /* @__PURE__ */ jsx("pre", { className: "text-xs text-muted-foreground whitespace-pre-wrap font-mono", children: content }) })
       }
     );
   }
 );
 ThinkingSection.displayName = "ThinkingSection";
-var ActionBar = React.forwardRef(
+var ActionBar = React11.forwardRef(
   ({
     response,
     isVisible,
@@ -274,6 +336,313 @@ var ActionBar = React.forwardRef(
   }
 );
 ActionBar.displayName = "ActionBar";
+function buildResponseString(questions, selectedOptions, freeformText) {
+  const parts = [];
+  for (const q of questions) {
+    const answer = selectedOptions[q];
+    if (answer) {
+      parts.push(`Q: ${q}
+A: ${answer}`);
+    }
+  }
+  const trimmed = freeformText.trim();
+  if (trimmed) {
+    parts.push(`Additional context: ${trimmed}`);
+  }
+  return parts.join("\n\n");
+}
+var HITLQuestionPanel = React11.forwardRef(({ question, onSubmit, onStop, className, ...props }, ref) => {
+  const [freeformText, setFreeformText] = useState("");
+  const [selectedOptions, setSelectedOptions] = useState({});
+  const hasTimeout = question.timeoutSeconds != null;
+  const [secondsLeft, setSecondsLeft] = useState(
+    () => hasTimeout ? Math.max(
+      0,
+      Math.round(
+        question.timeoutSeconds - (Date.now() - question.receivedAt) / 1e3
+      )
+    ) : Infinity
+  );
+  const textareaRef = useRef(null);
+  useEffect(() => {
+    textareaRef.current?.focus();
+  }, []);
+  useEffect(() => {
+    if (!hasTimeout) return;
+    const interval = setInterval(() => {
+      const remaining = Math.max(
+        0,
+        Math.round(
+          question.timeoutSeconds - (Date.now() - question.receivedAt) / 1e3
+        )
+      );
+      setSecondsLeft(remaining);
+      if (remaining <= 0) clearInterval(interval);
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [hasTimeout, question.timeoutSeconds, question.receivedAt]);
+  const timedOut = hasTimeout && secondsLeft <= 0;
+  const questionsWithOptions = useMemo(
+    () => question.questions.filter((q) => question.options?.[q]?.length),
+    [question.questions, question.options]
+  );
+  const allOptionsSelected = questionsWithOptions.length > 0 && questionsWithOptions.every((q) => selectedOptions[q]);
+  const hasFreeformText = freeformText.trim().length > 0;
+  const canSubmit = !timedOut && (allOptionsSelected || hasFreeformText);
+  const handleOptionClick = useCallback(
+    (questionText, option) => {
+      if (timedOut) return;
+      setSelectedOptions((prev) => {
+        if (prev[questionText] === option) {
+          const next = { ...prev };
+          delete next[questionText];
+          return next;
+        }
+        return { ...prev, [questionText]: option };
+      });
+    },
+    [timedOut]
+  );
+  const handleSubmit = useCallback(() => {
+    if (!canSubmit) return;
+    const combined = buildResponseString(
+      question.questions,
+      selectedOptions,
+      freeformText
+    );
+    onSubmit(combined, { selectedOptions, freeformText });
+  }, [canSubmit, question.questions, selectedOptions, freeformText, onSubmit]);
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        handleSubmit();
+      }
+    },
+    [handleSubmit]
+  );
+  const formatTime2 = (s) => {
+    const m = Math.floor(s / 60);
+    const sec = s % 60;
+    return `${m}:${sec.toString().padStart(2, "0")}`;
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref,
+      className: cn(
+        "rounded-lg border border-border bg-muted p-4 space-y-3",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-3", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex-1", children: /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-foreground", children: question.reason }) }),
+          hasTimeout && /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: cn(
+                "text-xs font-mono whitespace-nowrap",
+                secondsLeft <= 30 ? "text-destructive" : "text-muted-foreground"
+              ),
+              children: timedOut ? "Timed out" : formatTime2(secondsLeft)
+            }
+          )
+        ] }),
+        question.context && /* @__PURE__ */ jsx("div", { className: "text-xs text-muted-foreground bg-background rounded p-2 border border-border max-h-24 overflow-y-auto", children: /* @__PURE__ */ jsx("pre", { className: "whitespace-pre-wrap font-mono", children: question.context }) }),
+        /* @__PURE__ */ jsx("div", { className: "space-y-3", children: question.questions.map((q, i) => /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm text-foreground", children: q }),
+          question.options?.[q] && /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-2 mt-1.5", children: question.options[q].map((option, j) => {
+            const isSelected = selectedOptions[q] === option;
+            return /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: isSelected ? "primary" : "outline",
+                size: "sm",
+                onClick: () => handleOptionClick(q, option),
+                disabled: timedOut,
+                children: option
+              },
+              j
+            );
+          }) })
+        ] }, i)) }),
+        /* @__PURE__ */ jsx(
+          Textarea,
+          {
+            ref: textareaRef,
+            value: freeformText,
+            onChange: (e) => setFreeformText(e.target.value),
+            onKeyDown: handleKeyDown,
+            disabled: timedOut,
+            placeholder: "Add additional context or type a full response...",
+            rows: 2,
+            className: "resize-none"
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "ghost",
+              size: "sm",
+              onClick: onStop,
+              className: "text-destructive hover:text-destructive hover:bg-destructive/10",
+              children: "Stop agent"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "primary",
+              size: "sm",
+              onClick: handleSubmit,
+              disabled: !canSubmit,
+              children: "Send response"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+});
+HITLQuestionPanel.displayName = "HITLQuestionPanel";
+function parseResponse(response) {
+  const answers = {};
+  let additionalContext = null;
+  const blocks = response.split("\n\n");
+  for (const block of blocks) {
+    const qaMatch = block.match(/^Q: (.+)\nA: (.+)$/s);
+    if (qaMatch) {
+      answers[qaMatch[1].trim()] = qaMatch[2].trim();
+    } else if (block.startsWith("Additional context: ")) {
+      additionalContext = block.slice("Additional context: ".length).trim();
+    }
+  }
+  return { answers, additionalContext };
+}
+var HITLInteractionRecord = React11.forwardRef(({ interaction, className, ...props }, ref) => {
+  const { question, response, respondedAt } = interaction;
+  const timestamp = new Date(respondedAt).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+  const { answers, additionalContext } = useMemo(
+    () => parseResponse(response),
+    [response]
+  );
+  const hasParsedAnswers = Object.keys(answers).length > 0;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref,
+      className: cn(
+        "rounded-lg border border-border bg-muted p-3 space-y-2 text-sm",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsx("span", { className: "font-medium text-muted-foreground", children: "Clarifying Question" }),
+          /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: timestamp })
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "text-foreground font-medium", children: question.reason }),
+        question.context && /* @__PURE__ */ jsx("div", { className: "text-xs text-muted-foreground bg-background rounded p-2 border border-border", children: /* @__PURE__ */ jsx("pre", { className: "whitespace-pre-wrap font-mono", children: question.context }) }),
+        /* @__PURE__ */ jsx("div", { className: "space-y-2", children: question.questions.map((q, i) => /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("p", { className: "text-foreground", children: q }),
+          question.options?.[q] && /* @__PURE__ */ jsxs("p", { className: "text-xs text-muted-foreground ml-2", children: [
+            "Options: ",
+            question.options[q].join(", ")
+          ] }),
+          hasParsedAnswers && answers[q] && /* @__PURE__ */ jsxs("p", { className: "text-xs text-foreground ml-2 mt-0.5 bg-background rounded px-2 py-1 border border-border", children: [
+            /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "Answer: " }),
+            answers[q]
+          ] })
+        ] }, i)) }),
+        hasParsedAnswers && additionalContext && /* @__PURE__ */ jsxs("div", { className: "border-t border-border pt-2", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-xs", children: "Additional context:" }),
+          /* @__PURE__ */ jsx("p", { className: "text-foreground mt-0.5", children: additionalContext })
+        ] }),
+        !hasParsedAnswers && /* @__PURE__ */ jsxs("div", { className: "border-t border-border pt-2", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-xs", children: "Response:" }),
+          /* @__PURE__ */ jsx("p", { className: "text-foreground mt-0.5", children: response })
+        ] })
+      ]
+    }
+  );
+});
+HITLInteractionRecord.displayName = "HITLInteractionRecord";
+var HITLSection = React11.forwardRef(
+  ({
+    interactions,
+    defaultExpanded = false,
+    isExpanded: controlledExpanded,
+    onExpandedChange,
+    className,
+    ...props
+  }, ref) => {
+    const [uncontrolledExpanded, setUncontrolledExpanded] = useState(defaultExpanded);
+    const isControlled = controlledExpanded !== void 0;
+    const isExpanded = isControlled ? controlledExpanded : uncontrolledExpanded;
+    const toggleExpanded = useCallback(() => {
+      const newValue = !isExpanded;
+      if (isControlled) {
+        onExpandedChange?.(newValue);
+      } else {
+        setUncontrolledExpanded(newValue);
+      }
+    }, [isExpanded, isControlled, onExpandedChange]);
+    if (!interactions || interactions.length === 0) {
+      return null;
+    }
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        className: cn("border-t border-border", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              onClick: toggleExpanded,
+              className: "w-full flex items-center gap-2 py-2 px-3 hover:bg-muted/50 transition-colors text-left",
+              children: [
+                isExpanded ? /* @__PURE__ */ jsx(ChevronDown, { className: "w-3.5 h-3.5 text-muted-foreground flex-shrink-0" }) : /* @__PURE__ */ jsx(ChevronRight, { className: "w-3.5 h-3.5 text-muted-foreground flex-shrink-0" }),
+                /* @__PURE__ */ jsx(MessageCircleQuestion, { className: "w-3.5 h-3.5 text-muted-foreground flex-shrink-0" }),
+                /* @__PURE__ */ jsxs("span", { className: "text-xs font-medium text-foreground/80", children: [
+                  "Clarifying Questions (",
+                  interactions.length,
+                  ")"
+                ] })
+              ]
+            }
+          ),
+          isExpanded && /* @__PURE__ */ jsx("div", { className: "px-3 pb-3 space-y-2", children: interactions.map((interaction, i) => /* @__PURE__ */ jsx(HITLInteractionRecord, { interaction }, i)) })
+        ]
+      }
+    );
+  }
+);
+HITLSection.displayName = "HITLSection";
+var TruncatedMessage = React11.forwardRef(
+  ({ message, className, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: cn(
+          "text-xs text-muted-foreground truncate min-w-0",
+          className
+        ),
+        title: message,
+        ...props,
+        children: message
+      }
+    );
+  }
+);
+TruncatedMessage.displayName = "TruncatedMessage";
 function useThinkingTimer({
   startTime,
   endTime,
@@ -308,12 +677,133 @@ var initialAgentResponseState = {
   toolCalls: [],
   knowledge: [],
   memory: [],
+  statusUpdates: [],
   response: "",
   thinkingStartTime: null,
   responseCompleteTime: null,
   firstMessageTime: null
 };
 
+// src/components/agent-timeline/utils.ts
+function buildTimelineEntries(state) {
+  const entries = [];
+  if (state.thinkingSteps) {
+    let idx = 0;
+    for (const step of state.thinkingSteps) {
+      entries.push({
+        id: `tl-think-${idx++}`,
+        type: "thinking",
+        agentName: step.agentName ?? null,
+        parentAgent: step.parentAgent ?? null,
+        depth: step.depth ?? 0,
+        content: step.content,
+        title: step.label,
+        timestamp: step.timestamp ?? 0
+      });
+    }
+  } else if (state.thinking) {
+    entries.push({
+      id: "tl-think-0",
+      type: "thinking",
+      agentName: null,
+      parentAgent: null,
+      depth: 0,
+      content: state.thinking,
+      title: null,
+      timestamp: state.thinkingStartTime ?? 0
+    });
+  }
+  let toolIdx = 0;
+  for (const tool of state.toolCalls) {
+    entries.push({
+      id: `tl-tool-${toolIdx++}`,
+      type: "tool_call",
+      agentName: tool.agentName ?? null,
+      parentAgent: tool.parentAgent ?? null,
+      depth: tool.depth ?? 0,
+      content: tool.name,
+      title: null,
+      timestamp: tool.timestamp
+    });
+  }
+  let knowIdx = 0;
+  for (const item of state.knowledge) {
+    entries.push({
+      id: `tl-know-${knowIdx++}`,
+      type: "knowledge",
+      agentName: item.agentName ?? null,
+      parentAgent: item.parentAgent ?? null,
+      depth: item.depth ?? 0,
+      content: item.content,
+      title: item.source,
+      timestamp: item.timestamp
+    });
+  }
+  let memIdx = 0;
+  for (const item of state.memory) {
+    entries.push({
+      id: `tl-mem-${memIdx++}`,
+      type: "memory",
+      agentName: item.agentName ?? null,
+      parentAgent: item.parentAgent ?? null,
+      depth: item.depth ?? 0,
+      content: item.content,
+      title: item.type,
+      timestamp: item.timestamp
+    });
+  }
+  let statIdx = 0;
+  for (const item of state.statusUpdates) {
+    entries.push({
+      id: `tl-stat-${statIdx++}`,
+      type: "status_update",
+      agentName: item.agentName ?? item.agent ?? null,
+      parentAgent: item.parentAgent ?? null,
+      depth: item.depth ?? 0,
+      content: item.message,
+      title: null,
+      timestamp: item.timestamp
+    });
+  }
+  entries.sort((a, b) => a.timestamp - b.timestamp);
+  return entries;
+}
+function groupIntoAgentRuns(entries) {
+  const runs = [];
+  let currentRun = null;
+  for (const entry of entries) {
+    const name = entry.agentName || "Agent";
+    if (!currentRun || currentRun.agentName !== name) {
+      currentRun = {
+        agentName: name,
+        parentAgent: entry.parentAgent,
+        depth: entry.depth,
+        entries: []
+      };
+      runs.push(currentRun);
+    }
+    currentRun.entries.push({ entry, count: 1 });
+  }
+  for (const run of runs) {
+    run.entries = deduplicateEntries(run.entries);
+  }
+  return runs;
+}
+function deduplicateEntries(entries) {
+  if (entries.length === 0) return [];
+  const result = [entries[0]];
+  for (let i = 1; i < entries.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = entries[i];
+    if (prev.entry.type === curr.entry.type && prev.entry.content === curr.entry.content) {
+      prev.count += curr.count;
+    } else {
+      result.push({ ...curr });
+    }
+  }
+  return result;
+}
+
 // src/components/agent-response/hooks/useAgentResponseAccumulator.ts
 function useAgentResponseAccumulator(options) {
   const [state, setState] = useState(initialAgentResponseState);
@@ -342,16 +832,49 @@ function useAgentResponseAccumulator(options) {
             }
             return { ...prev, status: newStatus };
           case "thinking": {
+            if (payload.thinkingStep) {
+              const newStep = {
+                id: payload.thinkingStep.id || `step-${Date.now()}`,
+                label: payload.thinkingStep.label,
+                content: payload.thinkingStep.content,
+                depth: payload.thinkingStep.depth ?? payload.depth ?? 0,
+                isCollapsed: payload.thinkingStep.isCollapsed,
+                timestamp: Date.now(),
+                agentName: payload.agentName,
+                parentAgent: payload.parentAgent
+              };
+              const thinkingStartTime2 = prev.thinkingStartTime ?? Date.now();
+              const next2 = {
+                ...prev,
+                status: newStatus,
+                thinkingSteps: [...prev.thinkingSteps || [], newStep],
+                thinkingStartTime: thinkingStartTime2,
+                firstMessageTime
+              };
+              return { ...next2, timelineEntries: buildTimelineEntries(next2) };
+            }
             const newThinking = payload.message || payload.content || "";
             const separator = prev.thinking && newThinking ? "\n\n" : "";
             const thinkingStartTime = prev.thinkingStartTime ?? (newThinking ? Date.now() : null);
-            return {
+            const prevSteps = prev.thinkingSteps || [];
+            const plainStep = {
+              id: `step-${prevSteps.length}`,
+              label: newThinking,
+              content: newThinking,
+              depth: payload.depth ?? 0,
+              timestamp: Date.now(),
+              agentName: payload.agentName,
+              parentAgent: payload.parentAgent
+            };
+            const next = {
               ...prev,
               status: newStatus,
               thinking: prev.thinking + separator + newThinking,
+              thinkingSteps: [...prevSteps, plainStep],
               thinkingStartTime,
               firstMessageTime
             };
+            return { ...next, timelineEntries: buildTimelineEntries(next) };
           }
           case "tool_call": {
             const toolName = payload.message || payload.tool?.name;
@@ -360,14 +883,18 @@ function useAgentResponseAccumulator(options) {
                 id: payload.tool?.id || `tool-${Date.now()}`,
                 name: toolName,
                 arguments: payload.tool?.arguments,
-                timestamp: Date.now()
+                timestamp: Date.now(),
+                agentName: payload.agentName,
+                parentAgent: payload.parentAgent,
+                depth: payload.depth
               };
-              return {
+              const next = {
                 ...prev,
                 status: newStatus,
                 toolCalls: [...prev.toolCalls, newToolCall],
                 firstMessageTime
               };
+              return { ...next, timelineEntries: buildTimelineEntries(next) };
             }
             return { ...prev, status: newStatus, firstMessageTime };
           }
@@ -378,14 +905,18 @@ function useAgentResponseAccumulator(options) {
                 id: payload.knowledge?.id || `knowledge-${Date.now()}`,
                 source: payload.knowledge?.source || "unknown",
                 content: knowledgeContent,
-                timestamp: Date.now()
+                timestamp: Date.now(),
+                agentName: payload.agentName,
+                parentAgent: payload.parentAgent,
+                depth: payload.depth
               };
-              return {
+              const next = {
                 ...prev,
                 status: newStatus,
                 knowledge: [...prev.knowledge, newKnowledge],
                 firstMessageTime
               };
+              return { ...next, timelineEntries: buildTimelineEntries(next) };
             }
             return { ...prev, status: newStatus, firstMessageTime };
           }
@@ -396,14 +927,18 @@ function useAgentResponseAccumulator(options) {
                 id: payload.memory?.id || `memory-${Date.now()}`,
                 type: payload.memory?.type || "unknown",
                 content: memoryContent,
-                timestamp: Date.now()
+                timestamp: Date.now(),
+                agentName: payload.agentName,
+                parentAgent: payload.parentAgent,
+                depth: payload.depth
               };
-              return {
+              const next = {
                 ...prev,
                 status: newStatus,
                 memory: [...prev.memory, newMemory],
                 firstMessageTime
               };
+              return { ...next, timelineEntries: buildTimelineEntries(next) };
             }
             return { ...prev, status: newStatus, firstMessageTime };
           }
@@ -415,6 +950,28 @@ function useAgentResponseAccumulator(options) {
               responseCompleteTime: Date.now(),
               firstMessageTime: prev.firstMessageTime ?? Date.now()
             };
+          case "status_update": {
+            const statusMessage = payload.message || payload.statusUpdate?.message;
+            if (statusMessage) {
+              const newStatusItem = {
+                id: payload.statusUpdate?.id || `status-${Date.now()}`,
+                message: statusMessage,
+                agent: payload.statusUpdate?.agent,
+                timestamp: Date.now(),
+                agentName: payload.agentName,
+                parentAgent: payload.parentAgent,
+                depth: payload.depth
+              };
+              const next = {
+                ...prev,
+                status: newStatus,
+                statusUpdates: [...prev.statusUpdates, newStatusItem],
+                firstMessageTime
+              };
+              return { ...next, timelineEntries: buildTimelineEntries(next) };
+            }
+            return { ...prev, status: newStatus, firstMessageTime };
+          }
           default:
             return { ...prev, status: newStatus, firstMessageTime };
         }
@@ -427,7 +984,288 @@ function useAgentResponseAccumulator(options) {
   }, []);
   return { state, handleMessage, reset };
 }
-var AgentResponse = React.forwardRef(
+var ICON_MAP = {
+  thinking: Brain,
+  tool_call: Wrench,
+  knowledge: BookOpen,
+  memory: HardDrive,
+  status_update: Activity,
+  ai_response: MessageSquare,
+  error: AlertCircle
+};
+function TimelineItem({
+  displayEntry,
+  renderMarkdown,
+  isExpanded,
+  onToggleExpanded
+}) {
+  const { entry, count } = displayEntry;
+  const Icon = ICON_MAP[entry.type] ?? Activity;
+  const isLong = entry.content.length > 200 || entry.content.split("\n").length > 3;
+  const canExpand = isLong || entry.type === "ai_response";
+  return /* @__PURE__ */ jsxs("div", { className: "py-1 flex items-start gap-2 group", children: [
+    /* @__PURE__ */ jsx(Icon, { className: "w-3.5 h-3.5 text-muted-foreground flex-shrink-0 mt-0.5" }),
+    /* @__PURE__ */ jsx("div", { className: "min-w-0 flex-1", children: isExpanded && entry.type === "ai_response" && renderMarkdown ? (
+      // Expanded AI response: rendered markdown
+      /* @__PURE__ */ jsxs("div", { children: [
+        renderMarkdown(entry.content),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: onToggleExpanded,
+            className: "text-[10px] text-muted-foreground/70 hover:text-muted-foreground mt-1",
+            children: "Show less"
+          }
+        )
+      ] })
+    ) : isExpanded ? (
+      // Expanded non-AI: plain text
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("pre", { className: "text-xs text-muted-foreground whitespace-pre-wrap font-mono", children: entry.content }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: onToggleExpanded,
+            className: "text-[10px] text-muted-foreground/70 hover:text-muted-foreground mt-1",
+            children: "Show less"
+          }
+        )
+      ] })
+    ) : (
+      // Collapsed: truncated with optional expand
+      /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-1.5 min-w-0", children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: `text-xs text-muted-foreground min-w-0 ${canExpand ? "line-clamp-2 cursor-pointer hover:text-foreground/80" : ""}`,
+            onClick: canExpand ? onToggleExpanded : void 0,
+            children: entry.content
+          }
+        ),
+        count > 1 && /* @__PURE__ */ jsxs("span", { className: "text-[10px] text-muted-foreground/60 whitespace-nowrap flex-shrink-0", children: [
+          "(x",
+          count,
+          ")"
+        ] })
+      ] })
+    ) })
+  ] });
+}
+function TimelineAgentBlock({
+  block,
+  renderMarkdown,
+  isSingleAgent,
+  isCollapsed,
+  onToggleCollapsed,
+  expandedItems,
+  onToggleItemExpanded
+}) {
+  const indentPx = block.depth * 16;
+  if (isSingleAgent && block.depth === 0) {
+    return /* @__PURE__ */ jsx("div", { style: { paddingLeft: `${indentPx}px` }, children: block.entries.map((displayEntry, i) => /* @__PURE__ */ jsx(
+      TimelineItem,
+      {
+        displayEntry,
+        renderMarkdown,
+        isExpanded: expandedItems.has(displayEntry.entry.id),
+        onToggleExpanded: () => onToggleItemExpanded(displayEntry.entry.id)
+      },
+      displayEntry.entry.id + "-" + i
+    )) });
+  }
+  return /* @__PURE__ */ jsxs("div", { style: { paddingLeft: `${indentPx}px` }, children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: onToggleCollapsed,
+        className: "w-full flex items-center gap-1.5 py-1 hover:bg-muted/50 -ml-1 pl-1 pr-2 rounded transition-colors text-left",
+        children: [
+          isCollapsed ? /* @__PURE__ */ jsx(ChevronRight, { className: "w-3 h-3 text-muted-foreground flex-shrink-0" }) : /* @__PURE__ */ jsx(ChevronDown, { className: "w-3 h-3 text-muted-foreground flex-shrink-0" }),
+          /* @__PURE__ */ jsx("span", { className: "text-xs font-medium text-foreground/80", children: block.agentName }),
+          /* @__PURE__ */ jsxs("span", { className: "text-[10px] text-muted-foreground/60", children: [
+            "(",
+            block.entries.reduce((sum, e) => sum + e.count, 0),
+            ")"
+          ] })
+        ]
+      }
+    ),
+    !isCollapsed && /* @__PURE__ */ jsx("div", { className: "ml-4", children: block.entries.map((displayEntry, i) => /* @__PURE__ */ jsx(
+      TimelineItem,
+      {
+        displayEntry,
+        renderMarkdown,
+        isExpanded: expandedItems.has(displayEntry.entry.id),
+        onToggleExpanded: () => onToggleItemExpanded(displayEntry.entry.id)
+      },
+      displayEntry.entry.id + "-" + i
+    )) })
+  ] });
+}
+function createTimelineUIState() {
+  return {
+    expandedItems: /* @__PURE__ */ new Set(),
+    collapsedRuns: /* @__PURE__ */ new Set(),
+    activeFilters: /* @__PURE__ */ new Set()
+  };
+}
+var TYPE_CONFIG = [
+  { type: "status_update", icon: Activity, label: "Status" },
+  { type: "thinking", icon: Brain, label: "Thinking" },
+  { type: "tool_call", icon: Wrench, label: "Tools" },
+  { type: "knowledge", icon: BookOpen, label: "Knowledge" },
+  { type: "memory", icon: HardDrive, label: "Memory" },
+  { type: "ai_response", icon: MessageSquare, label: "AI" },
+  { type: "error", icon: AlertCircle, label: "Errors" }
+];
+function AgentTimeline({ entries, renderMarkdown, uiState, maxHeight = "300px" }) {
+  const containerRef = useRef(null);
+  const [renderTick, setRenderTick] = useState(0);
+  const forceRender = useCallback(() => setRenderTick((t) => t + 1), []);
+  const [internalExpandedItems] = useState(() => /* @__PURE__ */ new Set());
+  const [internalCollapsedRuns] = useState(() => /* @__PURE__ */ new Set());
+  const [internalActiveFilters] = useState(() => /* @__PURE__ */ new Set());
+  const expandedItems = uiState?.expandedItems ?? internalExpandedItems;
+  const collapsedRuns = uiState?.collapsedRuns ?? internalCollapsedRuns;
+  const activeFilters = uiState?.activeFilters ?? internalActiveFilters;
+  const availableTypes = useMemo(() => {
+    const types = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      types.add(entry.type);
+    }
+    return types;
+  }, [entries]);
+  const filteredEntries = useMemo(
+    () => activeFilters.size === 0 ? entries : entries.filter((e) => activeFilters.has(e.type)),
+    [entries, activeFilters, renderTick]
+  );
+  const agentRuns = useMemo(() => groupIntoAgentRuns(filteredEntries), [filteredEntries, renderTick]);
+  const toggleFilter = useCallback((type) => {
+    if (activeFilters.has(type)) {
+      activeFilters.delete(type);
+    } else {
+      activeFilters.add(type);
+    }
+    forceRender();
+  }, [activeFilters, forceRender]);
+  const clearFilters = useCallback(() => {
+    activeFilters.clear();
+    forceRender();
+  }, [activeFilters, forceRender]);
+  const toggleItemExpanded = useCallback((entryId) => {
+    if (expandedItems.has(entryId)) {
+      expandedItems.delete(entryId);
+    } else {
+      expandedItems.add(entryId);
+    }
+    forceRender();
+  }, [expandedItems, forceRender]);
+  const collapseAll = useCallback(() => {
+    collapsedRuns.clear();
+    agentRuns.forEach((run, i) => {
+      collapsedRuns.add(`${run.agentName}-${i}`);
+    });
+    expandedItems.clear();
+    forceRender();
+  }, [agentRuns, collapsedRuns, expandedItems, forceRender]);
+  const expandAll = useCallback(() => {
+    collapsedRuns.clear();
+    agentRuns.forEach((run, i) => {
+      collapsedRuns.add(`${run.agentName}-${i}:expanded`);
+    });
+    forceRender();
+  }, [agentRuns, collapsedRuns, forceRender]);
+  if (entries.length === 0) return null;
+  const isSingle = agentRuns.length === 1;
+  const hasActiveFilter = activeFilters.size > 0;
+  const scrollStyle = maxHeight !== "none" ? { maxHeight } : void 0;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: containerRef,
+      className: `-mt-1 ${maxHeight !== "none" ? "overflow-y-auto scrollbar-thin" : ""}`,
+      style: scrollStyle,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "sticky top-0 z-10 bg-background flex items-center gap-1 py-1.5 mb-1 border-b border-border/50 flex-wrap", children: [
+          TYPE_CONFIG.filter((tc) => availableTypes.has(tc.type)).map((tc) => {
+            const isActive = activeFilters.has(tc.type);
+            const count = entries.filter((e) => e.type === tc.type).length;
+            return /* @__PURE__ */ jsxs(
+              "button",
+              {
+                onClick: () => toggleFilter(tc.type),
+                className: `inline-flex items-center gap-1 px-1.5 py-0.5 rounded text-[10px] transition-colors ${isActive ? "bg-accent text-accent-foreground ring-1 ring-accent-foreground/20" : "text-muted-foreground/60 hover:text-muted-foreground hover:bg-muted/50"}`,
+                title: `${isActive ? "Hide" : "Show only"} ${tc.label}`,
+                children: [
+                  /* @__PURE__ */ jsx(tc.icon, { className: "w-3 h-3" }),
+                  /* @__PURE__ */ jsx("span", { children: count })
+                ]
+              },
+              tc.type
+            );
+          }),
+          hasActiveFilter && /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: clearFilters,
+              className: "text-[10px] text-muted-foreground/60 hover:text-muted-foreground px-1",
+              children: "Clear"
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: "flex-1" }),
+          !isSingle && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: collapseAll,
+                className: "inline-flex items-center gap-0.5 text-[10px] text-muted-foreground/60 hover:text-muted-foreground px-1 py-0.5 rounded hover:bg-muted/50 transition-colors",
+                title: "Collapse all",
+                children: /* @__PURE__ */ jsx(ChevronsDownUp, { className: "w-3 h-3" })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: expandAll,
+                className: "inline-flex items-center gap-0.5 text-[10px] text-muted-foreground/60 hover:text-muted-foreground px-1 py-0.5 rounded hover:bg-muted/50 transition-colors",
+                title: "Expand all",
+                children: /* @__PURE__ */ jsx(ChevronsUpDown, { className: "w-3 h-3" })
+              }
+            )
+          ] })
+        ] }),
+        filteredEntries.length === 0 ? /* @__PURE__ */ jsx("div", { className: "text-[10px] text-muted-foreground/50 py-2 text-center", children: "No entries match the selected filters" }) : /* @__PURE__ */ jsx("div", { className: "space-y-0.5", children: agentRuns.map((run, i) => {
+          const runKey = `${run.agentName}-${i}`;
+          const defaultCollapsed = run.depth > 0;
+          const isCollapsed = collapsedRuns.has(runKey) ? true : collapsedRuns.has(`${runKey}:expanded`) ? false : defaultCollapsed;
+          return /* @__PURE__ */ jsx(
+            TimelineAgentBlock,
+            {
+              block: run,
+              renderMarkdown,
+              isSingleAgent: isSingle,
+              isCollapsed,
+              onToggleCollapsed: () => {
+                if (isCollapsed) {
+                  collapsedRuns.delete(runKey);
+                  collapsedRuns.add(`${runKey}:expanded`);
+                } else {
+                  collapsedRuns.delete(`${runKey}:expanded`);
+                  collapsedRuns.add(runKey);
+                }
+                forceRender();
+              },
+              expandedItems,
+              onToggleItemExpanded: toggleItemExpanded
+            },
+            runKey
+          );
+        }) })
+      ]
+    }
+  );
+}
+var AgentResponse = React11.forwardRef(
   ({
     state,
     id,
@@ -439,10 +1277,15 @@ var AgentResponse = React.forwardRef(
     thinkingExpanded: controlledThinkingExpanded,
     onThinkingExpandedChange,
     actionsVisible = "hover",
+    hitlInteractions,
+    defaultHITLExpanded = false,
+    statusContent,
     renderMarkdown,
+    renderThinkingMarkdown,
     className,
     ...props
   }, ref) => {
+    const timelineUIStateRef = useRef(createTimelineUIState());
     const [uncontrolledExpanded, setUncontrolledExpanded] = useState(defaultThinkingExpanded);
     const isThinkingControlled = controlledThinkingExpanded !== void 0;
     const thinkingExpanded = isThinkingControlled ? controlledThinkingExpanded : uncontrolledExpanded;
@@ -464,8 +1307,11 @@ var AgentResponse = React.forwardRef(
       if (!state.firstMessageTime || !state.responseCompleteTime) return 0;
       return (state.responseCompleteTime - state.firstMessageTime) / 1e3;
     }, [state.firstMessageTime, state.responseCompleteTime]);
-    const hasAnyContent = state.thinking || state.toolCalls.length > 0 || state.knowledge.length > 0 || state.memory.length > 0 || state.response;
-    const showMetadataRow = state.thinking || state.toolCalls.length > 0 || state.knowledge.length > 0 || state.memory.length > 0 || state.status === "processing";
+    const hasTimelineEntries = !!(state.timelineEntries && state.timelineEntries.length > 0);
+    const hasThinkingContent = !!state.thinking || state.thinkingSteps && state.thinkingSteps.length > 0 || hasTimelineEntries || false;
+    const hasHITLInteractions = hitlInteractions && hitlInteractions.length > 0;
+    const hasAnyContent = hasThinkingContent || state.toolCalls.length > 0 || state.knowledge.length > 0 || state.memory.length > 0 || state.statusUpdates.length > 0 || hasHITLInteractions || state.response;
+    const showMetadataRow = hasThinkingContent || state.toolCalls.length > 0 || state.knowledge.length > 0 || state.memory.length > 0 || state.statusUpdates.length > 0 || state.status === "processing";
     const showActionBar = state.status === "complete" && state.response;
     const isActionBarVisible = actionsVisible === true || actionsVisible === "hover" && isHovered;
     if (!hasAnyContent) {
@@ -485,24 +1331,41 @@ var AgentResponse = React.forwardRef(
               /* @__PURE__ */ jsx(
                 MetadataRow,
                 {
-                  hasThinking: !!state.thinking,
+                  hasThinking: hasThinkingContent,
                   isExpanded: thinkingExpanded,
                   onToggle: toggleThinking,
                   toolCalls: state.toolCalls,
                   knowledge: state.knowledge,
                   memory: state.memory,
+                  statusUpdates: state.statusUpdates,
+                  statusContent,
                   status: state.status,
                   elapsedTime
                 }
               ),
-              /* @__PURE__ */ jsx(
+              hasTimelineEntries ? thinkingExpanded && /* @__PURE__ */ jsx("div", { className: "px-3 pb-3 border-t border-border mt-2", children: /* @__PURE__ */ jsx(
+                AgentTimeline,
+                {
+                  entries: state.timelineEntries,
+                  renderMarkdown: renderThinkingMarkdown,
+                  uiState: timelineUIStateRef.current
+                }
+              ) }) : /* @__PURE__ */ jsx(
                 ThinkingSection,
                 {
-                  content: state.thinking,
-                  isExpanded: thinkingExpanded
+                  content: state.thinkingSteps && state.thinkingSteps.length > 0 ? state.thinkingSteps : state.thinking,
+                  isExpanded: thinkingExpanded,
+                  renderMarkdown: renderThinkingMarkdown
                 }
               )
             ] }),
+            hasHITLInteractions && /* @__PURE__ */ jsx(
+              HITLSection,
+              {
+                interactions: hitlInteractions,
+                defaultExpanded: defaultHITLExpanded
+              }
+            ),
             state.response && /* @__PURE__ */ jsx(
               "div",
               {
@@ -531,7 +1394,378 @@ var AgentResponse = React.forwardRef(
   }
 );
 AgentResponse.displayName = "AgentResponse";
+var UserPrompt = React11.forwardRef(
+  ({ content, timestamp, className, ...props }, ref) => {
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        className: cn(
+          "w-fit max-w-[80%] rounded-lg px-4 pt-3.5 pb-3",
+          "bg-secondary text-secondary-foreground",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx("p", { className: "whitespace-pre-wrap", children: content }),
+          timestamp && /* @__PURE__ */ jsx("p", { className: "text-xs text-secondary-foreground/70 mt-1", children: timestamp.toLocaleTimeString([], {
+            hour: "2-digit",
+            minute: "2-digit"
+          }) })
+        ]
+      }
+    );
+  }
+);
+UserPrompt.displayName = "UserPrompt";
+function createCodeBlockDecorate(entry) {
+  const [node, path] = entry;
+  const ranges = [];
+  if (!Text.isText(node)) {
+    return ranges;
+  }
+  const { text } = node;
+  const backtickPositions = [];
+  let searchStart = 0;
+  while (true) {
+    const pos = text.indexOf("```", searchStart);
+    if (pos === -1) break;
+    backtickPositions.push(pos);
+    searchStart = pos + 3;
+  }
+  let i = 0;
+  while (i < backtickPositions.length) {
+    const openPos = backtickPositions[i];
+    const closePos = backtickPositions[i + 1];
+    ranges.push({
+      anchor: { path, offset: openPos },
+      focus: { path, offset: openPos + 3 },
+      codeDelimiter: true
+    });
+    if (closePos !== void 0) {
+      if (closePos > openPos + 3) {
+        ranges.push({
+          anchor: { path, offset: openPos + 3 },
+          focus: { path, offset: closePos },
+          codeBlock: true
+        });
+      }
+      ranges.push({
+        anchor: { path, offset: closePos },
+        focus: { path, offset: closePos + 3 },
+        codeDelimiter: true
+      });
+      i += 2;
+    } else {
+      if (text.length > openPos + 3) {
+        ranges.push({
+          anchor: { path, offset: openPos + 3 },
+          focus: { path, offset: text.length },
+          codeBlock: true
+        });
+      }
+      i += 1;
+    }
+  }
+  return ranges;
+}
+function CodeBlockLeaf({ attributes, children, leaf }) {
+  const leafAny = leaf;
+  if (leafAny.codeBlock) {
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        ...attributes,
+        className: "bg-muted/50 text-muted-foreground font-mono text-sm rounded px-1",
+        children
+      }
+    );
+  }
+  if (leafAny.codeDelimiter) {
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        ...attributes,
+        className: "text-muted-foreground/50 font-mono text-sm",
+        children
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx("span", { ...attributes, children });
+}
+var UserPromptInput = React11.forwardRef(
+  ({
+    value = "",
+    onChange,
+    onSubmit,
+    clearOnSubmit = true,
+    placeholder = "Type your message...",
+    disabled = false,
+    isSubmitting = false,
+    onStop,
+    disableWhileSubmitting = true,
+    autoFocus = false,
+    refocusAfterSubmit = false,
+    onReady,
+    minRows = 1,
+    maxRows = 6,
+    renderActions,
+    enableTags = false,
+    onTagCreate,
+    onTagDelete,
+    className,
+    ...props
+  }, ref) => {
+    const editorRef = React11.useRef(null);
+    const [internalValue, setInternalValue] = React11.useState(value);
+    const prevIsSubmitting = React11.useRef(isSubmitting);
+    const hasEmittedReady = React11.useRef(false);
+    React11.useEffect(() => {
+      setInternalValue(value);
+    }, [value]);
+    React11.useEffect(() => {
+      if (autoFocus) {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            editorRef.current?.focus();
+          });
+        });
+      }
+    }, [autoFocus]);
+    React11.useEffect(() => {
+      if (!hasEmittedReady.current && onReady) {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            hasEmittedReady.current = true;
+            onReady();
+          });
+        });
+      }
+    }, [onReady]);
+    React11.useEffect(() => {
+      if (refocusAfterSubmit && prevIsSubmitting.current && !isSubmitting) {
+        requestAnimationFrame(() => {
+          editorRef.current?.focus();
+        });
+      }
+      prevIsSubmitting.current = isSubmitting;
+    }, [isSubmitting, refocusAfterSubmit]);
+    React11.useImperativeHandle(
+      ref,
+      () => ({
+        focus: () => {
+          try {
+            editorRef.current?.focus();
+          } catch {
+            requestAnimationFrame(() => {
+              requestAnimationFrame(() => {
+                editorRef.current?.focus();
+              });
+            });
+          }
+        },
+        clear: () => {
+          editorRef.current?.clear();
+          setInternalValue("");
+        },
+        getText: () => editorRef.current?.getText() ?? "",
+        insertText: (text) => editorRef.current?.insertText(text)
+      }),
+      []
+    );
+    const handleChange = React11.useCallback(
+      (newValue) => {
+        setInternalValue(newValue);
+        onChange?.(newValue);
+      },
+      [onChange]
+    );
+    const handleSubmit = React11.useCallback(
+      (text) => {
+        if (disabled || isSubmitting) return;
+        if (!text.trim()) return;
+        onSubmit?.(text.trim());
+        if (clearOnSubmit) {
+          editorRef.current?.clear();
+          setInternalValue("");
+        }
+      },
+      [disabled, isSubmitting, onSubmit, clearOnSubmit]
+    );
+    const handleSendClick = React11.useCallback(() => {
+      const text = editorRef.current?.getText() ?? "";
+      handleSubmit(text);
+    }, [handleSubmit]);
+    const hasContent = internalValue.trim().length > 0;
+    const canSubmit = hasContent && !disabled && !isSubmitting;
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "rounded-lg border border-input bg-background",
+          disabled && "opacity-50 cursor-not-allowed",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "pl-2 pr-0 pt-1 pb-1", children: /* @__PURE__ */ jsx(
+            SlateEditor,
+            {
+              ref: editorRef,
+              value: internalValue,
+              onChange: handleChange,
+              onSubmit: handleSubmit,
+              clearOnSubmit: false,
+              placeholder,
+              disabled: disabled || disableWhileSubmitting && isSubmitting,
+              enableTags,
+              onTagCreate,
+              onTagDelete,
+              minRows,
+              maxRows,
+              decorate: createCodeBlockDecorate,
+              renderLeaf: CodeBlockLeaf
+            }
+          ) }),
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between pl-2 pr-1 pb-1 pt-1", children: [
+            /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1", children: renderActions?.() }),
+            isSubmitting && onStop ? /* @__PURE__ */ jsx(
+              IconButton,
+              {
+                icon: /* @__PURE__ */ jsx(Square, {}),
+                variant: "filled",
+                size: "sm",
+                "aria-label": "Stop",
+                onClick: onStop
+              }
+            ) : /* @__PURE__ */ jsx(
+              IconButton,
+              {
+                icon: isSubmitting ? /* @__PURE__ */ jsx(Loader2, { className: "animate-spin" }) : /* @__PURE__ */ jsx(Send, {}),
+                variant: "filled",
+                size: "sm",
+                "aria-label": isSubmitting ? "Sending..." : "Send message",
+                disabled: !canSubmit,
+                onClick: handleSendClick
+              }
+            )
+          ] })
+        ]
+      }
+    );
+  }
+);
+UserPromptInput.displayName = "UserPromptInput";
+
+// src/components/inline-actions/parseResponseSegments.ts
+var ACTION_BLOCK_REGEX = /```json:action\s*\n([\s\S]*?)```/g;
+function parseResponseSegments(text) {
+  if (!text) return [];
+  const segments = [];
+  let lastIndex = 0;
+  ACTION_BLOCK_REGEX.lastIndex = 0;
+  let match;
+  while ((match = ACTION_BLOCK_REGEX.exec(text)) !== null) {
+    const before = text.slice(lastIndex, match.index);
+    if (before.trim()) {
+      segments.push({ kind: "markdown", content: before });
+    }
+    const jsonContent = match[1].trim();
+    let parsed = null;
+    try {
+      parsed = JSON.parse(jsonContent);
+    } catch {
+    }
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      segments.push({
+        kind: "action",
+        actionType: parsed.type,
+        payload: parsed
+      });
+    } else {
+      const rawBlock = match[0];
+      segments.push({ kind: "markdown", content: rawBlock });
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  const trailing = text.slice(lastIndex);
+  if (trailing.trim()) {
+    segments.push({ kind: "markdown", content: trailing });
+  }
+  return segments;
+}
+function ActionMarkdownRenderer({
+  content,
+  registry,
+  renderMarkdown,
+  onAction,
+  isLatest
+}) {
+  const segments = useMemo(() => parseResponseSegments(content), [content]);
+  if (segments.length === 1 && segments[0].kind === "markdown") {
+    return /* @__PURE__ */ jsx(Fragment, { children: renderMarkdown(segments[0].content) });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: segments.map((segment, index) => {
+    if (segment.kind === "markdown") {
+      return /* @__PURE__ */ jsx("div", { children: renderMarkdown(segment.content) }, `md-${index}`);
+    }
+    const Component = registry[segment.actionType];
+    if (!Component) {
+      return /* @__PURE__ */ jsx(
+        "pre",
+        {
+          className: "my-4 p-4 rounded-lg border border-border bg-muted text-sm font-mono overflow-x-auto",
+          children: /* @__PURE__ */ jsx("code", { children: JSON.stringify(segment.payload, null, 2) })
+        },
+        `action-fallback-${index}`
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      Component,
+      {
+        payload: segment.payload,
+        onAction,
+        isLatest
+      },
+      `action-${segment.actionType}-${index}`
+    );
+  }) });
+}
+
+// src/components/inline-actions/prompts.ts
+var INLINE_ACTION_PROMPT = `
+<inline_actions>
+When your response should include interactive components (like query viewers,
+data tables, or executable actions), embed them as fenced code blocks using
+the \`json:action\` language tag:
+
+\`\`\`json:action
+{
+  "type": "action-type-here",
+  ...action-specific fields
+}
+\`\`\`
+
+Rules:
+- Each block must contain valid JSON with a "type" field.
+- The "type" must match a registered action component on the frontend.
+- Multiple action blocks per response are allowed.
+- Surround action blocks with normal markdown text for user context.
+- The action block is rendered as an interactive component in the chat UI.
+- SQL strings inside JSON must be properly escaped (newlines as \\n, quotes as \\").
+
+Available action types:
+
+- "optimap-query": Displays SQL queries with a button to execute them and
+  update the 3D globe map.
+  Required fields:
+    - type: "optimap-query"
+    - locations_sql: string (the validated locations SQL query)
+    - routes_sql: string (the validated routes SQL query)
+    - database_name: string (the target database name)
+</inline_actions>
+`;
 
-export { ActionBar, ActivityIndicators, AgentResponse, MetadataRow, ThinkingSection, formatTime, formatTotalTime, initialAgentResponseState, useAgentResponseAccumulator, useThinkingTimer };
+export { ActionBar, ActionMarkdownRenderer, ActivityIndicators, AgentResponse, AgentTimeline, HITLInteractionRecord, HITLQuestionPanel, HITLSection, INLINE_ACTION_PROMPT, MetadataRow, ThinkingSection, TruncatedMessage, UserPrompt, UserPromptInput, buildResponseString, buildTimelineEntries, createTimelineUIState, deduplicateEntries, formatTime, formatTotalTime, groupIntoAgentRuns, initialAgentResponseState, parseResponseSegments, useAgentResponseAccumulator, useThinkingTimer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map