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

package/dist/index.cjs

@@ -255,7 +255,7 @@ var ThinkingSection = React11__namespace.forwardRef(
         ref,
         className: core.cn("px-3 pb-3 border-t border-border", className),
         ...props,
-        children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 max-h-[200px] overflow-y-auto", children: isStructured ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-0", children: content.map((step) => /* @__PURE__ */ jsxRuntime.jsx(
+        children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 max-h-[200px] overflow-y-auto scrollbar-thin", children: isStructured ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-0", children: content.map((step) => /* @__PURE__ */ jsxRuntime.jsx(
           ThinkingStepItem,
           {
             step,
@@ -431,7 +431,7 @@ var HITLQuestionPanel = React11__namespace.forwardRef(({ question, onSubmit, onS
       selectedOptions,
       freeformText
     );
-    onSubmit(combined);
+    onSubmit(combined, { selectedOptions, freeformText });
   }, [canSubmit, question.questions, selectedOptions, freeformText, onSubmit]);
   const handleKeyDown = React11.useCallback(
     (e) => {
@@ -705,6 +705,126 @@ var initialAgentResponseState = {
   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] = React11.useState(initialAgentResponseState);
@@ -738,28 +858,44 @@ function useAgentResponseAccumulator(options) {
                 id: payload.thinkingStep.id || `step-${Date.now()}`,
                 label: payload.thinkingStep.label,
                 content: payload.thinkingStep.content,
-                depth: payload.thinkingStep.depth ?? 0,
-                isCollapsed: payload.thinkingStep.isCollapsed
+                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();
-              return {
+              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;
@@ -768,14 +904,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 };
           }
@@ -786,14 +926,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 };
           }
@@ -804,14 +948,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 };
           }
@@ -830,14 +978,18 @@ function useAgentResponseAccumulator(options) {
                 id: payload.statusUpdate?.id || `status-${Date.now()}`,
                 message: statusMessage,
                 agent: payload.statusUpdate?.agent,
-                timestamp: Date.now()
+                timestamp: Date.now(),
+                agentName: payload.agentName,
+                parentAgent: payload.parentAgent,
+                depth: payload.depth
               };
-              return {
+              const next = {
                 ...prev,
                 status: newStatus,
                 statusUpdates: [...prev.statusUpdates, newStatusItem],
                 firstMessageTime
               };
+              return { ...next, timelineEntries: buildTimelineEntries(next) };
             }
             return { ...prev, status: newStatus, firstMessageTime };
           }
@@ -853,6 +1005,287 @@ function useAgentResponseAccumulator(options) {
   }, []);
   return { state, handleMessage, reset };
 }
+var ICON_MAP = {
+  thinking: lucideReact.Brain,
+  tool_call: lucideReact.Wrench,
+  knowledge: lucideReact.BookOpen,
+  memory: lucideReact.HardDrive,
+  status_update: lucideReact.Activity,
+  ai_response: lucideReact.MessageSquare,
+  error: lucideReact.AlertCircle
+};
+function TimelineItem({
+  displayEntry,
+  renderMarkdown,
+  isExpanded,
+  onToggleExpanded
+}) {
+  const { entry, count } = displayEntry;
+  const Icon = ICON_MAP[entry.type] ?? lucideReact.Activity;
+  const isLong = entry.content.length > 200 || entry.content.split("\n").length > 3;
+  const canExpand = isLong || entry.type === "ai_response";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "py-1 flex items-start gap-2 group", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "w-3.5 h-3.5 text-muted-foreground flex-shrink-0 mt-0.5" }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "min-w-0 flex-1", children: isExpanded && entry.type === "ai_response" && renderMarkdown ? (
+      // Expanded AI response: rendered markdown
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        renderMarkdown(entry.content),
+        /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "text-xs text-muted-foreground whitespace-pre-wrap font-mono", children: entry.content }),
+        /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs("div", { className: "flex items-baseline gap-1.5 min-w-0", children: [
+        /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.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__ */ jsxRuntime.jsx("div", { style: { paddingLeft: `${indentPx}px` }, children: block.entries.map((displayEntry, i) => /* @__PURE__ */ jsxRuntime.jsx(
+      TimelineItem,
+      {
+        displayEntry,
+        renderMarkdown,
+        isExpanded: expandedItems.has(displayEntry.entry.id),
+        onToggleExpanded: () => onToggleItemExpanded(displayEntry.entry.id)
+      },
+      displayEntry.entry.id + "-" + i
+    )) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { paddingLeft: `${indentPx}px` }, children: [
+    /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(lucideReact.ChevronRight, { className: "w-3 h-3 text-muted-foreground flex-shrink-0" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronDown, { className: "w-3 h-3 text-muted-foreground flex-shrink-0" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium text-foreground/80", children: block.agentName }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-[10px] text-muted-foreground/60", children: [
+            "(",
+            block.entries.reduce((sum, e) => sum + e.count, 0),
+            ")"
+          ] })
+        ]
+      }
+    ),
+    !isCollapsed && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ml-4", children: block.entries.map((displayEntry, i) => /* @__PURE__ */ jsxRuntime.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: lucideReact.Activity, label: "Status" },
+  { type: "thinking", icon: lucideReact.Brain, label: "Thinking" },
+  { type: "tool_call", icon: lucideReact.Wrench, label: "Tools" },
+  { type: "knowledge", icon: lucideReact.BookOpen, label: "Knowledge" },
+  { type: "memory", icon: lucideReact.HardDrive, label: "Memory" },
+  { type: "ai_response", icon: lucideReact.MessageSquare, label: "AI" },
+  { type: "error", icon: lucideReact.AlertCircle, label: "Errors" }
+];
+function AgentTimeline({ entries, renderMarkdown, uiState, maxHeight = "300px" }) {
+  const containerRef = React11.useRef(null);
+  const [renderTick, setRenderTick] = React11.useState(0);
+  const forceRender = React11.useCallback(() => setRenderTick((t) => t + 1), []);
+  const [internalExpandedItems] = React11.useState(() => /* @__PURE__ */ new Set());
+  const [internalCollapsedRuns] = React11.useState(() => /* @__PURE__ */ new Set());
+  const [internalActiveFilters] = React11.useState(() => /* @__PURE__ */ new Set());
+  const expandedItems = uiState?.expandedItems ?? internalExpandedItems;
+  const collapsedRuns = uiState?.collapsedRuns ?? internalCollapsedRuns;
+  const activeFilters = uiState?.activeFilters ?? internalActiveFilters;
+  const availableTypes = React11.useMemo(() => {
+    const types = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      types.add(entry.type);
+    }
+    return types;
+  }, [entries]);
+  const filteredEntries = React11.useMemo(
+    () => activeFilters.size === 0 ? entries : entries.filter((e) => activeFilters.has(e.type)),
+    [entries, activeFilters, renderTick]
+  );
+  const agentRuns = React11.useMemo(() => groupIntoAgentRuns(filteredEntries), [filteredEntries, renderTick]);
+  const toggleFilter = React11.useCallback((type) => {
+    if (activeFilters.has(type)) {
+      activeFilters.delete(type);
+    } else {
+      activeFilters.add(type);
+    }
+    forceRender();
+  }, [activeFilters, forceRender]);
+  const clearFilters = React11.useCallback(() => {
+    activeFilters.clear();
+    forceRender();
+  }, [activeFilters, forceRender]);
+  const toggleItemExpanded = React11.useCallback((entryId) => {
+    if (expandedItems.has(entryId)) {
+      expandedItems.delete(entryId);
+    } else {
+      expandedItems.add(entryId);
+    }
+    forceRender();
+  }, [expandedItems, forceRender]);
+  const collapseAll = React11.useCallback(() => {
+    collapsedRuns.clear();
+    agentRuns.forEach((run, i) => {
+      collapsedRuns.add(`${run.agentName}-${i}`);
+    });
+    expandedItems.clear();
+    forceRender();
+  }, [agentRuns, collapsedRuns, expandedItems, forceRender]);
+  const expandAll = React11.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__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref: containerRef,
+      className: `-mt-1 ${maxHeight !== "none" ? "overflow-y-auto scrollbar-thin" : ""}`,
+      style: scrollStyle,
+      children: [
+        /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.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__ */ jsxRuntime.jsx(tc.icon, { className: "w-3 h-3" }),
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { children: count })
+                ]
+              },
+              tc.type
+            );
+          }),
+          hasActiveFilter && /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: clearFilters,
+              className: "text-[10px] text-muted-foreground/60 hover:text-muted-foreground px-1",
+              children: "Clear"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1" }),
+          !isSingle && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(lucideReact.ChevronsDownUp, { className: "w-3 h-3" })
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(lucideReact.ChevronsUpDown, { className: "w-3 h-3" })
+              }
+            )
+          ] })
+        ] }),
+        filteredEntries.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-[10px] text-muted-foreground/50 py-2 text-center", children: "No entries match the selected filters" }) : /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.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__namespace.forwardRef(
   ({
     state,
@@ -873,6 +1306,7 @@ var AgentResponse = React11__namespace.forwardRef(
     className,
     ...props
   }, ref) => {
+    const timelineUIStateRef = React11.useRef(createTimelineUIState());
     const [uncontrolledExpanded, setUncontrolledExpanded] = React11.useState(defaultThinkingExpanded);
     const isThinkingControlled = controlledThinkingExpanded !== void 0;
     const thinkingExpanded = isThinkingControlled ? controlledThinkingExpanded : uncontrolledExpanded;
@@ -894,7 +1328,8 @@ var AgentResponse = React11__namespace.forwardRef(
       if (!state.firstMessageTime || !state.responseCompleteTime) return 0;
       return (state.responseCompleteTime - state.firstMessageTime) / 1e3;
     }, [state.firstMessageTime, state.responseCompleteTime]);
-    const hasThinkingContent = !!state.thinking || state.thinkingSteps && state.thinkingSteps.length > 0 || false;
+    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";
@@ -929,7 +1364,14 @@ var AgentResponse = React11__namespace.forwardRef(
                   elapsedTime
                 }
               ),
-              /* @__PURE__ */ jsxRuntime.jsx(
+              hasTimelineEntries ? thinkingExpanded && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 pb-3 border-t border-border mt-2", children: /* @__PURE__ */ jsxRuntime.jsx(
+                AgentTimeline,
+                {
+                  entries: state.timelineEntries,
+                  renderMarkdown: renderThinkingMarkdown,
+                  uiState: timelineUIStateRef.current
+                }
+              ) }) : /* @__PURE__ */ jsxRuntime.jsx(
                 ThinkingSection,
                 {
                   content: state.thinkingSteps && state.thinkingSteps.length > 0 ? state.thinkingSteps : state.thinking,
@@ -1236,21 +1678,138 @@ var UserPromptInput = React11__namespace.forwardRef(
 );
 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 = React11.useMemo(() => parseResponseSegments(content), [content]);
+  if (segments.length === 1 && segments[0].kind === "markdown") {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderMarkdown(segments[0].content) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: segments.map((segment, index) => {
+    if (segment.kind === "markdown") {
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { children: renderMarkdown(segment.content) }, `md-${index}`);
+    }
+    const Component = registry[segment.actionType];
+    if (!Component) {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "pre",
+        {
+          className: "my-4 p-4 rounded-lg border border-border bg-muted text-sm font-mono overflow-x-auto",
+          children: /* @__PURE__ */ jsxRuntime.jsx("code", { children: JSON.stringify(segment.payload, null, 2) })
+        },
+        `action-fallback-${index}`
+      );
+    }
+    return /* @__PURE__ */ jsxRuntime.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>
+`;
+
 exports.ActionBar = ActionBar;
+exports.ActionMarkdownRenderer = ActionMarkdownRenderer;
 exports.ActivityIndicators = ActivityIndicators;
 exports.AgentResponse = AgentResponse;
+exports.AgentTimeline = AgentTimeline;
 exports.HITLInteractionRecord = HITLInteractionRecord;
 exports.HITLQuestionPanel = HITLQuestionPanel;
 exports.HITLSection = HITLSection;
+exports.INLINE_ACTION_PROMPT = INLINE_ACTION_PROMPT;
 exports.MetadataRow = MetadataRow;
 exports.ThinkingSection = ThinkingSection;
 exports.TruncatedMessage = TruncatedMessage;
 exports.UserPrompt = UserPrompt;
 exports.UserPromptInput = UserPromptInput;
 exports.buildResponseString = buildResponseString;
+exports.buildTimelineEntries = buildTimelineEntries;
+exports.createTimelineUIState = createTimelineUIState;
+exports.deduplicateEntries = deduplicateEntries;
 exports.formatTime = formatTime;
 exports.formatTotalTime = formatTotalTime;
+exports.groupIntoAgentRuns = groupIntoAgentRuns;
 exports.initialAgentResponseState = initialAgentResponseState;
+exports.parseResponseSegments = parseResponseSegments;
 exports.useAgentResponseAccumulator = useAgentResponseAccumulator;
 exports.useThinkingTimer = useThinkingTimer;
 //# sourceMappingURL=index.cjs.map