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

package/dist/index.cjs

@@ -1,9 +1,10 @@
 'use strict';
 
-var React = require('react');
+var React11 = require('react');
 var core = require('@optilogic/core');
 var lucideReact = require('lucide-react');
 var jsxRuntime = require('react/jsx-runtime');
+var editor = require('@optilogic/editor');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -23,14 +24,34 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var React11__namespace = /*#__PURE__*/_interopNamespace(React11);
 
 // src/components/agent-response/AgentResponse.tsx
-var ActivityIndicators = React__namespace.forwardRef(
-  ({ toolCalls, knowledge, memory, className, ...props }, ref) => {
-    const hasAnyActivity = toolCalls.length > 0 || knowledge.length > 0 || memory.length > 0;
+var ActivityIndicators = React11__namespace.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__ */ jsxRuntime.jsxs("div", { ref, className: core.cn("flex items-center gap-2", className), ...props, children: [
+      statusUpdates.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(core.Popover, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(core.PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            className: "flex items-center gap-1 text-muted-foreground hover:text-foreground transition-colors",
+            onClick: (e) => e.stopPropagation(),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Activity, { className: "w-3.5 h-3.5" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs", children: statusUpdates.length })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx(core.PopoverContent, { className: "w-80", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h4", { className: "font-medium text-sm", children: "Status Updates" }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2 max-h-60 overflow-auto", children: statusUpdates.map((item) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-2 bg-muted rounded text-xs", children: [
+            item.agent && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-medium text-muted-foreground", children: item.agent }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: item.agent ? "mt-1" : "", children: item.message })
+          ] }, item.id)) })
+        ] }) })
+      ] }),
       toolCalls.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(core.Popover, { children: [
         /* @__PURE__ */ jsxRuntime.jsx(core.PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(
           "button",
@@ -125,7 +146,7 @@ function formatTotalTime(seconds) {
   const minutes = seconds / 60;
   return `${minutes.toFixed(1)}m`;
 }
-var MetadataRow = React__namespace.forwardRef(
+var MetadataRow = React11__namespace.forwardRef(
   ({
     hasThinking,
     isExpanded,
@@ -133,6 +154,8 @@ var MetadataRow = React__namespace.forwardRef(
     toolCalls,
     knowledge,
     memory,
+    statusUpdates = [],
+    statusContent,
     status,
     elapsedTime,
     className,
@@ -140,7 +163,7 @@ var MetadataRow = React__namespace.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__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
@@ -157,7 +180,7 @@ var MetadataRow = React__namespace.forwardRef(
       return null;
     };
     const leftContent = renderLeftContent();
-    if (!leftContent && !hasActivity) {
+    if (!leftContent && !hasActivity && !statusContent) {
       return null;
     }
     return /* @__PURE__ */ jsxRuntime.jsxs(
@@ -171,16 +194,18 @@ var MetadataRow = React__namespace.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__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1.5", children: leftContent }),
+          ) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1.5 shrink-0", children: leftContent }),
+          statusContent && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 min-w-0 mx-2", children: statusContent }),
           /* @__PURE__ */ jsxRuntime.jsx(
             ActivityIndicators,
             {
               toolCalls,
               knowledge,
-              memory
+              memory,
+              statusUpdates
             }
           )
         ]
@@ -189,24 +214,61 @@ var MetadataRow = React__namespace.forwardRef(
   }
 );
 MetadataRow.displayName = "MetadataRow";
-var ThinkingSection = React__namespace.forwardRef(
-  ({ content, isExpanded, className, ...props }, ref) => {
-    if (!isExpanded || !content) {
+var ThinkingStepItem = ({ step, renderMarkdown }) => {
+  const [isCollapsed, setIsCollapsed] = React11.useState(step.isCollapsed ?? false);
+  const toggleCollapse = React11.useCallback(() => {
+    setIsCollapsed((prev) => !prev);
+  }, []);
+  const indentPadding = step.depth * 16;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border-b border-border/50 last:border-b-0", children: [
+    /* @__PURE__ */ jsxRuntime.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__ */ 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: step.label })
+        ]
+      }
+    ),
+    !isCollapsed && /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: "pb-2 px-2",
+        style: { paddingLeft: `${indentPadding + 28}px` },
+        children: renderMarkdown ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-muted-foreground", children: renderMarkdown(step.content) }) : /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "text-xs text-muted-foreground whitespace-pre-wrap font-mono", children: step.content })
+      }
+    )
+  ] });
+};
+var ThinkingSection = React11__namespace.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__ */ jsxRuntime.jsx(
       "div",
       {
         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: /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "text-xs text-muted-foreground whitespace-pre-wrap font-mono", children: content }) })
+        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(
+          ThinkingStepItem,
+          {
+            step,
+            renderMarkdown
+          },
+          step.id
+        )) }) : renderMarkdown ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-muted-foreground", children: renderMarkdown(content) }) : /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "text-xs text-muted-foreground whitespace-pre-wrap font-mono", children: content }) })
       }
     );
   }
 );
 ThinkingSection.displayName = "ThinkingSection";
-var ActionBar = React__namespace.forwardRef(
+var ActionBar = React11__namespace.forwardRef(
   ({
     response,
     isVisible,
@@ -217,8 +279,8 @@ var ActionBar = React__namespace.forwardRef(
     className,
     ...props
   }, ref) => {
-    const [copied, setCopied] = React.useState(false);
-    const handleCopy = React.useCallback(async () => {
+    const [copied, setCopied] = React11.useState(false);
+    const handleCopy = React11.useCallback(async () => {
       try {
         await navigator.clipboard.writeText(response);
         setCopied(true);
@@ -228,11 +290,11 @@ var ActionBar = React__namespace.forwardRef(
         console.error("Failed to copy response:", err);
       }
     }, [response, onResponseCopy]);
-    const handleThumbsUp = React.useCallback(() => {
+    const handleThumbsUp = React11.useCallback(() => {
       const newValue = feedback === "up" ? null : "up";
       onFeedbackChange?.(newValue);
     }, [feedback, onFeedbackChange]);
-    const handleThumbsDown = React.useCallback(() => {
+    const handleThumbsDown = React11.useCallback(() => {
       const newValue = feedback === "down" ? null : "down";
       onFeedbackChange?.(newValue);
     }, [feedback, onFeedbackChange]);
@@ -295,13 +357,320 @@ var ActionBar = React__namespace.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__namespace.forwardRef(({ question, onSubmit, onStop, className, ...props }, ref) => {
+  const [freeformText, setFreeformText] = React11.useState("");
+  const [selectedOptions, setSelectedOptions] = React11.useState({});
+  const hasTimeout = question.timeoutSeconds != null;
+  const [secondsLeft, setSecondsLeft] = React11.useState(
+    () => hasTimeout ? Math.max(
+      0,
+      Math.round(
+        question.timeoutSeconds - (Date.now() - question.receivedAt) / 1e3
+      )
+    ) : Infinity
+  );
+  const textareaRef = React11.useRef(null);
+  React11.useEffect(() => {
+    textareaRef.current?.focus();
+  }, []);
+  React11.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 = React11.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 = React11.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 = React11.useCallback(() => {
+    if (!canSubmit) return;
+    const combined = buildResponseString(
+      question.questions,
+      selectedOptions,
+      freeformText
+    );
+    onSubmit(combined);
+  }, [canSubmit, question.questions, selectedOptions, freeformText, onSubmit]);
+  const handleKeyDown = React11.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__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref,
+      className: core.cn(
+        "rounded-lg border border-border bg-muted p-4 space-y-3",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start justify-between gap-3", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm font-medium text-foreground", children: question.reason }) }),
+          hasTimeout && /* @__PURE__ */ jsxRuntime.jsx(
+            "span",
+            {
+              className: core.cn(
+                "text-xs font-mono whitespace-nowrap",
+                secondsLeft <= 30 ? "text-destructive" : "text-muted-foreground"
+              ),
+              children: timedOut ? "Timed out" : formatTime2(secondsLeft)
+            }
+          )
+        ] }),
+        question.context && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-muted-foreground bg-background rounded p-2 border border-border max-h-24 overflow-y-auto", children: /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "whitespace-pre-wrap font-mono", children: question.context }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-3", children: question.questions.map((q, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-foreground", children: q }),
+          question.options?.[q] && /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
+              core.Button,
+              {
+                variant: isSelected ? "primary" : "outline",
+                size: "sm",
+                onClick: () => handleOptionClick(q, option),
+                disabled: timedOut,
+                children: option
+              },
+              j
+            );
+          }) })
+        ] }, i)) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          core.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__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            core.Button,
+            {
+              variant: "ghost",
+              size: "sm",
+              onClick: onStop,
+              className: "text-destructive hover:text-destructive hover:bg-destructive/10",
+              children: "Stop agent"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            core.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__namespace.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 } = React11.useMemo(
+    () => parseResponse(response),
+    [response]
+  );
+  const hasParsedAnswers = Object.keys(answers).length > 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref,
+      className: core.cn(
+        "rounded-lg border border-border bg-muted p-3 space-y-2 text-sm",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium text-muted-foreground", children: "Clarifying Question" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground", children: timestamp })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-foreground font-medium", children: question.reason }),
+        question.context && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-muted-foreground bg-background rounded p-2 border border-border", children: /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "whitespace-pre-wrap font-mono", children: question.context }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2", children: question.questions.map((q, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-foreground", children: q }),
+          question.options?.[q] && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-xs text-muted-foreground ml-2", children: [
+            "Options: ",
+            question.options[q].join(", ")
+          ] }),
+          hasParsedAnswers && answers[q] && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-xs text-foreground ml-2 mt-0.5 bg-background rounded px-2 py-1 border border-border", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: "Answer: " }),
+            answers[q]
+          ] })
+        ] }, i)) }),
+        hasParsedAnswers && additionalContext && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border-t border-border pt-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-xs", children: "Additional context:" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-foreground mt-0.5", children: additionalContext })
+        ] }),
+        !hasParsedAnswers && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border-t border-border pt-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-xs", children: "Response:" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-foreground mt-0.5", children: response })
+        ] })
+      ]
+    }
+  );
+});
+HITLInteractionRecord.displayName = "HITLInteractionRecord";
+var HITLSection = React11__namespace.forwardRef(
+  ({
+    interactions,
+    defaultExpanded = false,
+    isExpanded: controlledExpanded,
+    onExpandedChange,
+    className,
+    ...props
+  }, ref) => {
+    const [uncontrolledExpanded, setUncontrolledExpanded] = React11.useState(defaultExpanded);
+    const isControlled = controlledExpanded !== void 0;
+    const isExpanded = isControlled ? controlledExpanded : uncontrolledExpanded;
+    const toggleExpanded = React11.useCallback(() => {
+      const newValue = !isExpanded;
+      if (isControlled) {
+        onExpandedChange?.(newValue);
+      } else {
+        setUncontrolledExpanded(newValue);
+      }
+    }, [isExpanded, isControlled, onExpandedChange]);
+    if (!interactions || interactions.length === 0) {
+      return null;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        ref,
+        className: core.cn("border-t border-border", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(lucideReact.ChevronDown, { className: "w-3.5 h-3.5 text-muted-foreground flex-shrink-0" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronRight, { className: "w-3.5 h-3.5 text-muted-foreground flex-shrink-0" }),
+                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.MessageCircleQuestion, { className: "w-3.5 h-3.5 text-muted-foreground flex-shrink-0" }),
+                /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs font-medium text-foreground/80", children: [
+                  "Clarifying Questions (",
+                  interactions.length,
+                  ")"
+                ] })
+              ]
+            }
+          ),
+          isExpanded && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 pb-3 space-y-2", children: interactions.map((interaction, i) => /* @__PURE__ */ jsxRuntime.jsx(HITLInteractionRecord, { interaction }, i)) })
+        ]
+      }
+    );
+  }
+);
+HITLSection.displayName = "HITLSection";
+var TruncatedMessage = React11__namespace.forwardRef(
+  ({ message, className, ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref,
+        className: core.cn(
+          "text-xs text-muted-foreground truncate min-w-0",
+          className
+        ),
+        title: message,
+        ...props,
+        children: message
+      }
+    );
+  }
+);
+TruncatedMessage.displayName = "TruncatedMessage";
 function useThinkingTimer({
   startTime,
   endTime,
   status
 }) {
-  const [elapsed, setElapsed] = React.useState(0);
-  React.useEffect(() => {
+  const [elapsed, setElapsed] = React11.useState(0);
+  React11.useEffect(() => {
     if (!startTime) {
       setElapsed(0);
       return;
@@ -329,6 +698,7 @@ var initialAgentResponseState = {
   toolCalls: [],
   knowledge: [],
   memory: [],
+  statusUpdates: [],
   response: "",
   thinkingStartTime: null,
   responseCompleteTime: null,
@@ -337,9 +707,9 @@ var initialAgentResponseState = {
 
 // src/components/agent-response/hooks/useAgentResponseAccumulator.ts
 function useAgentResponseAccumulator(options) {
-  const [state, setState] = React.useState(initialAgentResponseState);
+  const [state, setState] = React11.useState(initialAgentResponseState);
   const topic = options?.topic;
-  const handleMessage = React.useCallback(
+  const handleMessage = React11.useCallback(
     (message) => {
       let payload;
       if (topic) {
@@ -363,6 +733,23 @@ 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 ?? 0,
+                isCollapsed: payload.thinkingStep.isCollapsed
+              };
+              const thinkingStartTime2 = prev.thinkingStartTime ?? Date.now();
+              return {
+                ...prev,
+                status: newStatus,
+                thinkingSteps: [...prev.thinkingSteps || [], newStep],
+                thinkingStartTime: thinkingStartTime2,
+                firstMessageTime
+              };
+            }
             const newThinking = payload.message || payload.content || "";
             const separator = prev.thinking && newThinking ? "\n\n" : "";
             const thinkingStartTime = prev.thinkingStartTime ?? (newThinking ? Date.now() : null);
@@ -436,6 +823,24 @@ 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()
+              };
+              return {
+                ...prev,
+                status: newStatus,
+                statusUpdates: [...prev.statusUpdates, newStatusItem],
+                firstMessageTime
+              };
+            }
+            return { ...prev, status: newStatus, firstMessageTime };
+          }
           default:
             return { ...prev, status: newStatus, firstMessageTime };
         }
@@ -443,12 +848,12 @@ function useAgentResponseAccumulator(options) {
     },
     [topic]
   );
-  const reset = React.useCallback(() => {
+  const reset = React11.useCallback(() => {
     setState(initialAgentResponseState);
   }, []);
   return { state, handleMessage, reset };
 }
-var AgentResponse = React__namespace.forwardRef(
+var AgentResponse = React11__namespace.forwardRef(
   ({
     state,
     id,
@@ -460,14 +865,18 @@ var AgentResponse = React__namespace.forwardRef(
     thinkingExpanded: controlledThinkingExpanded,
     onThinkingExpandedChange,
     actionsVisible = "hover",
+    hitlInteractions,
+    defaultHITLExpanded = false,
+    statusContent,
     renderMarkdown,
+    renderThinkingMarkdown,
     className,
     ...props
   }, ref) => {
-    const [uncontrolledExpanded, setUncontrolledExpanded] = React.useState(defaultThinkingExpanded);
+    const [uncontrolledExpanded, setUncontrolledExpanded] = React11.useState(defaultThinkingExpanded);
     const isThinkingControlled = controlledThinkingExpanded !== void 0;
     const thinkingExpanded = isThinkingControlled ? controlledThinkingExpanded : uncontrolledExpanded;
-    const toggleThinking = React.useCallback(() => {
+    const toggleThinking = React11.useCallback(() => {
       const newValue = !thinkingExpanded;
       if (isThinkingControlled) {
         onThinkingExpandedChange?.(newValue);
@@ -475,18 +884,20 @@ var AgentResponse = React__namespace.forwardRef(
         setUncontrolledExpanded(newValue);
       }
     }, [thinkingExpanded, isThinkingControlled, onThinkingExpandedChange]);
-    const [isHovered, setIsHovered] = React.useState(false);
+    const [isHovered, setIsHovered] = React11.useState(false);
     const elapsedTime = useThinkingTimer({
       startTime: state.thinkingStartTime,
       endTime: state.responseCompleteTime,
       status: state.status
     });
-    const totalTimeSeconds = React.useMemo(() => {
+    const totalTimeSeconds = React11.useMemo(() => {
       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 hasThinkingContent = !!state.thinking || state.thinkingSteps && state.thinkingSteps.length > 0 || 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) {
@@ -506,12 +917,14 @@ var AgentResponse = React__namespace.forwardRef(
               /* @__PURE__ */ jsxRuntime.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
                 }
@@ -519,11 +932,19 @@ var AgentResponse = React__namespace.forwardRef(
               /* @__PURE__ */ jsxRuntime.jsx(
                 ThinkingSection,
                 {
-                  content: state.thinking,
-                  isExpanded: thinkingExpanded
+                  content: state.thinkingSteps && state.thinkingSteps.length > 0 ? state.thinkingSteps : state.thinking,
+                  isExpanded: thinkingExpanded,
+                  renderMarkdown: renderThinkingMarkdown
                 }
               )
             ] }),
+            hasHITLInteractions && /* @__PURE__ */ jsxRuntime.jsx(
+              HITLSection,
+              {
+                interactions: hitlInteractions,
+                defaultExpanded: defaultHITLExpanded
+              }
+            ),
             state.response && /* @__PURE__ */ jsxRuntime.jsx(
               "div",
               {
@@ -552,12 +973,281 @@ var AgentResponse = React__namespace.forwardRef(
   }
 );
 AgentResponse.displayName = "AgentResponse";
+var UserPrompt = React11__namespace.forwardRef(
+  ({ content, timestamp, className, ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        ref,
+        className: core.cn(
+          "w-fit max-w-[80%] rounded-lg px-4 pt-3.5 pb-3",
+          "bg-secondary text-secondary-foreground",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "whitespace-pre-wrap", children: content }),
+          timestamp && /* @__PURE__ */ jsxRuntime.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 (!editor.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__ */ jsxRuntime.jsx(
+      "span",
+      {
+        ...attributes,
+        className: "bg-muted/50 text-muted-foreground font-mono text-sm rounded px-1",
+        children
+      }
+    );
+  }
+  if (leafAny.codeDelimiter) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "span",
+      {
+        ...attributes,
+        className: "text-muted-foreground/50 font-mono text-sm",
+        children
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { ...attributes, children });
+}
+var UserPromptInput = React11__namespace.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__namespace.useRef(null);
+    const [internalValue, setInternalValue] = React11__namespace.useState(value);
+    const prevIsSubmitting = React11__namespace.useRef(isSubmitting);
+    const hasEmittedReady = React11__namespace.useRef(false);
+    React11__namespace.useEffect(() => {
+      setInternalValue(value);
+    }, [value]);
+    React11__namespace.useEffect(() => {
+      if (autoFocus) {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            editorRef.current?.focus();
+          });
+        });
+      }
+    }, [autoFocus]);
+    React11__namespace.useEffect(() => {
+      if (!hasEmittedReady.current && onReady) {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            hasEmittedReady.current = true;
+            onReady();
+          });
+        });
+      }
+    }, [onReady]);
+    React11__namespace.useEffect(() => {
+      if (refocusAfterSubmit && prevIsSubmitting.current && !isSubmitting) {
+        requestAnimationFrame(() => {
+          editorRef.current?.focus();
+        });
+      }
+      prevIsSubmitting.current = isSubmitting;
+    }, [isSubmitting, refocusAfterSubmit]);
+    React11__namespace.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__namespace.useCallback(
+      (newValue) => {
+        setInternalValue(newValue);
+        onChange?.(newValue);
+      },
+      [onChange]
+    );
+    const handleSubmit = React11__namespace.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__namespace.useCallback(() => {
+      const text = editorRef.current?.getText() ?? "";
+      handleSubmit(text);
+    }, [handleSubmit]);
+    const hasContent = internalValue.trim().length > 0;
+    const canSubmit = hasContent && !disabled && !isSubmitting;
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: core.cn(
+          "rounded-lg border border-input bg-background",
+          disabled && "opacity-50 cursor-not-allowed",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "pl-2 pr-0 pt-1 pb-1", children: /* @__PURE__ */ jsxRuntime.jsx(
+            editor.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__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between pl-2 pr-1 pb-1 pt-1", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1", children: renderActions?.() }),
+            isSubmitting && onStop ? /* @__PURE__ */ jsxRuntime.jsx(
+              core.IconButton,
+              {
+                icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Square, {}),
+                variant: "filled",
+                size: "sm",
+                "aria-label": "Stop",
+                onClick: onStop
+              }
+            ) : /* @__PURE__ */ jsxRuntime.jsx(
+              core.IconButton,
+              {
+                icon: isSubmitting ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "animate-spin" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Send, {}),
+                variant: "filled",
+                size: "sm",
+                "aria-label": isSubmitting ? "Sending..." : "Send message",
+                disabled: !canSubmit,
+                onClick: handleSendClick
+              }
+            )
+          ] })
+        ]
+      }
+    );
+  }
+);
+UserPromptInput.displayName = "UserPromptInput";
 
 exports.ActionBar = ActionBar;
 exports.ActivityIndicators = ActivityIndicators;
 exports.AgentResponse = AgentResponse;
+exports.HITLInteractionRecord = HITLInteractionRecord;
+exports.HITLQuestionPanel = HITLQuestionPanel;
+exports.HITLSection = HITLSection;
 exports.MetadataRow = MetadataRow;
 exports.ThinkingSection = ThinkingSection;
+exports.TruncatedMessage = TruncatedMessage;
+exports.UserPrompt = UserPrompt;
+exports.UserPromptInput = UserPromptInput;
+exports.buildResponseString = buildResponseString;
 exports.formatTime = formatTime;
 exports.formatTotalTime = formatTotalTime;
 exports.initialAgentResponseState = initialAgentResponseState;