@optilogic/chat 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Optilogic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,567 @@
+'use strict';
+
+var React = require('react');
+var core = require('@optilogic/core');
+var lucideReact = require('lucide-react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// 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;
+    if (!hasAnyActivity) return null;
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref, className: core.cn("flex items-center gap-2", className), ...props, children: [
+      toolCalls.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.Wrench, { className: "w-3.5 h-3.5" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs", children: toolCalls.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: "Tool Calls" }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2 max-h-60 overflow-auto", children: toolCalls.map((tool) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-2 bg-muted rounded text-xs", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-medium", children: tool.name }),
+            tool.arguments && /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "mt-1 text-muted-foreground overflow-x-auto", children: JSON.stringify(tool.arguments, null, 2) })
+          ] }, tool.id)) })
+        ] }) })
+      ] }),
+      knowledge.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.Book, { className: "w-3.5 h-3.5" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs", children: knowledge.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: "Knowledge Retrieved" }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2 max-h-60 overflow-auto", children: knowledge.map((item) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-2 bg-muted rounded text-xs", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-medium", children: item.source }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-1 text-muted-foreground", children: item.content })
+          ] }, item.id)) })
+        ] }) })
+      ] }),
+      memory.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.HardDrive, { className: "w-3.5 h-3.5" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs", children: memory.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: "Memory Accessed" }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2 max-h-60 overflow-auto", children: memory.map((item) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-2 bg-muted rounded text-xs", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-medium", children: item.type }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-1 text-muted-foreground", children: item.content })
+          ] }, item.id)) })
+        ] }) })
+      ] })
+    ] });
+  }
+);
+ActivityIndicators.displayName = "ActivityIndicators";
+
+// src/components/agent-response/utils.ts
+function formatTime(seconds, isComplete) {
+  if (seconds < 1) {
+    return isComplete ? "<1s" : "0s";
+  }
+  if (isComplete) {
+    if (seconds < 60) {
+      return `${Math.round(seconds)}s`;
+    }
+    const minutes = seconds / 60;
+    return `${minutes.toFixed(1)} min`;
+  }
+  if (seconds < 60) {
+    return `${Math.floor(seconds)}s`;
+  }
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function formatTotalTime(seconds) {
+  if (seconds < 1) {
+    return "<1s";
+  }
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const minutes = seconds / 60;
+  return `${minutes.toFixed(1)}m`;
+}
+var MetadataRow = React__namespace.forwardRef(
+  ({
+    hasThinking,
+    isExpanded,
+    onToggle,
+    toolCalls,
+    knowledge,
+    memory,
+    status,
+    elapsedTime,
+    className,
+    ...props
+  }, ref) => {
+    const isProcessing = status === "processing";
+    const isComplete = status === "complete";
+    const hasActivity = toolCalls.length > 0 || knowledge.length > 0 || memory.length > 0;
+    const renderLeftContent = () => {
+      if (hasThinking) {
+        return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
+          isExpanded ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronUp, { className: "w-3.5 h-3.5 text-muted-foreground" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronDown, { className: "w-3.5 h-3.5 text-muted-foreground" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground", children: isComplete ? `Thought for ${formatTime(elapsedTime, true)}` : `Thinking... ${formatTime(elapsedTime, false)}` })
+        ] });
+      }
+      if (isProcessing) {
+        return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(core.LoadingSpinner, { size: "sm", variant: "muted", className: "w-3.5 h-3.5" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground", children: "Processing" })
+        ] });
+      }
+      return null;
+    };
+    const leftContent = renderLeftContent();
+    if (!leftContent && !hasActivity) {
+      return null;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        ref,
+        className: core.cn("w-full flex items-center justify-between px-3 py-2", className),
+        ...props,
+        children: [
+          hasThinking ? /* @__PURE__ */ jsxRuntime.jsx(
+            "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",
+              children: leftContent
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1.5", children: leftContent }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ActivityIndicators,
+            {
+              toolCalls,
+              knowledge,
+              memory
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+MetadataRow.displayName = "MetadataRow";
+var ThinkingSection = React__namespace.forwardRef(
+  ({ content, isExpanded, className, ...props }, ref) => {
+    if (!isExpanded || !content) {
+      return null;
+    }
+    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 }) })
+      }
+    );
+  }
+);
+ThinkingSection.displayName = "ThinkingSection";
+var ActionBar = React__namespace.forwardRef(
+  ({
+    response,
+    isVisible,
+    totalTimeSeconds,
+    feedback,
+    onFeedbackChange,
+    onResponseCopy,
+    className,
+    ...props
+  }, ref) => {
+    const [copied, setCopied] = React.useState(false);
+    const handleCopy = React.useCallback(async () => {
+      try {
+        await navigator.clipboard.writeText(response);
+        setCopied(true);
+        setTimeout(() => setCopied(false), 2e3);
+        onResponseCopy?.(response);
+      } catch (err) {
+        console.error("Failed to copy response:", err);
+      }
+    }, [response, onResponseCopy]);
+    const handleThumbsUp = React.useCallback(() => {
+      const newValue = feedback === "up" ? null : "up";
+      onFeedbackChange?.(newValue);
+    }, [feedback, onFeedbackChange]);
+    const handleThumbsDown = React.useCallback(() => {
+      const newValue = feedback === "down" ? null : "down";
+      onFeedbackChange?.(newValue);
+    }, [feedback, onFeedbackChange]);
+    const isThumbsUp = feedback === "up";
+    const isThumbsDown = feedback === "down";
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        ref,
+        className: core.cn(
+          "flex items-center justify-between px-4 py-2",
+          "transition-opacity duration-200",
+          isVisible ? "opacity-100" : "opacity-0 pointer-events-none",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                onClick: handleCopy,
+                className: "p-1.5 rounded hover:bg-muted transition-colors text-muted-foreground hover:text-foreground",
+                title: copied ? "Copied!" : "Copy response",
+                children: copied ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "w-4 h-4 text-green-500" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Copy, { className: "w-4 h-4" })
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                onClick: handleThumbsUp,
+                className: core.cn(
+                  "p-1.5 rounded hover:bg-muted transition-colors",
+                  isThumbsUp ? "text-green-500" : "text-muted-foreground hover:text-foreground"
+                ),
+                title: "Good response",
+                children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ThumbsUp, { className: core.cn("w-4 h-4", isThumbsUp && "fill-current") })
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                onClick: handleThumbsDown,
+                className: core.cn(
+                  "p-1.5 rounded hover:bg-muted transition-colors",
+                  isThumbsDown ? "text-red-500" : "text-muted-foreground hover:text-foreground"
+                ),
+                title: "Poor response",
+                children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ThumbsDown, { className: core.cn("w-4 h-4", isThumbsDown && "fill-current") })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs text-muted-foreground", children: [
+            "Total time: ",
+            formatTotalTime(totalTimeSeconds)
+          ] })
+        ]
+      }
+    );
+  }
+);
+ActionBar.displayName = "ActionBar";
+function useThinkingTimer({
+  startTime,
+  endTime,
+  status
+}) {
+  const [elapsed, setElapsed] = React.useState(0);
+  React.useEffect(() => {
+    if (!startTime) {
+      setElapsed(0);
+      return;
+    }
+    if (status === "complete" && endTime) {
+      setElapsed((endTime - startTime) / 1e3);
+      return;
+    }
+    if (status === "processing") {
+      const updateElapsed = () => {
+        setElapsed((Date.now() - startTime) / 1e3);
+      };
+      updateElapsed();
+      const interval = setInterval(updateElapsed, 1e3);
+      return () => clearInterval(interval);
+    }
+  }, [startTime, endTime, status]);
+  return elapsed;
+}
+
+// src/components/agent-response/types.ts
+var initialAgentResponseState = {
+  status: "idle",
+  thinking: "",
+  toolCalls: [],
+  knowledge: [],
+  memory: [],
+  response: "",
+  thinkingStartTime: null,
+  responseCompleteTime: null,
+  firstMessageTime: null
+};
+
+// src/components/agent-response/hooks/useAgentResponseAccumulator.ts
+function useAgentResponseAccumulator(options) {
+  const [state, setState] = React.useState(initialAgentResponseState);
+  const topic = options?.topic;
+  const handleMessage = React.useCallback(
+    (message) => {
+      let payload;
+      if (topic) {
+        const msg = message;
+        if (msg.topic !== topic) return;
+        payload = msg.message;
+      } else {
+        payload = message;
+      }
+      setState((prev) => {
+        let newStatus = prev.status;
+        const isFirstMessage = prev.status === "idle" && payload.type !== "status";
+        if (isFirstMessage) {
+          newStatus = "processing";
+        }
+        const firstMessageTime = prev.firstMessageTime ?? (isFirstMessage ? Date.now() : null);
+        switch (payload.type) {
+          case "status":
+            if (payload.message === "Harness connected" || payload.status === "Harness connected") {
+              return { ...initialAgentResponseState };
+            }
+            return { ...prev, status: newStatus };
+          case "thinking": {
+            const newThinking = payload.message || payload.content || "";
+            const separator = prev.thinking && newThinking ? "\n\n" : "";
+            const thinkingStartTime = prev.thinkingStartTime ?? (newThinking ? Date.now() : null);
+            return {
+              ...prev,
+              status: newStatus,
+              thinking: prev.thinking + separator + newThinking,
+              thinkingStartTime,
+              firstMessageTime
+            };
+          }
+          case "tool_call": {
+            const toolName = payload.message || payload.tool?.name;
+            if (toolName) {
+              const newToolCall = {
+                id: payload.tool?.id || `tool-${Date.now()}`,
+                name: toolName,
+                arguments: payload.tool?.arguments,
+                timestamp: Date.now()
+              };
+              return {
+                ...prev,
+                status: newStatus,
+                toolCalls: [...prev.toolCalls, newToolCall],
+                firstMessageTime
+              };
+            }
+            return { ...prev, status: newStatus, firstMessageTime };
+          }
+          case "knowledge": {
+            const knowledgeContent = payload.message || payload.knowledge?.content;
+            if (knowledgeContent) {
+              const newKnowledge = {
+                id: payload.knowledge?.id || `knowledge-${Date.now()}`,
+                source: payload.knowledge?.source || "unknown",
+                content: knowledgeContent,
+                timestamp: Date.now()
+              };
+              return {
+                ...prev,
+                status: newStatus,
+                knowledge: [...prev.knowledge, newKnowledge],
+                firstMessageTime
+              };
+            }
+            return { ...prev, status: newStatus, firstMessageTime };
+          }
+          case "memory": {
+            const memoryContent = payload.message || payload.memory?.content;
+            if (memoryContent) {
+              const newMemory = {
+                id: payload.memory?.id || `memory-${Date.now()}`,
+                type: payload.memory?.type || "unknown",
+                content: memoryContent,
+                timestamp: Date.now()
+              };
+              return {
+                ...prev,
+                status: newStatus,
+                memory: [...prev.memory, newMemory],
+                firstMessageTime
+              };
+            }
+            return { ...prev, status: newStatus, firstMessageTime };
+          }
+          case "response":
+            return {
+              ...prev,
+              status: "complete",
+              response: payload.message || payload.content || "",
+              responseCompleteTime: Date.now(),
+              firstMessageTime: prev.firstMessageTime ?? Date.now()
+            };
+          default:
+            return { ...prev, status: newStatus, firstMessageTime };
+        }
+      });
+    },
+    [topic]
+  );
+  const reset = React.useCallback(() => {
+    setState(initialAgentResponseState);
+  }, []);
+  return { state, handleMessage, reset };
+}
+var AgentResponse = React__namespace.forwardRef(
+  ({
+    state,
+    id,
+    timestamp,
+    feedback,
+    onFeedbackChange,
+    onResponseCopy,
+    defaultThinkingExpanded = false,
+    thinkingExpanded: controlledThinkingExpanded,
+    onThinkingExpandedChange,
+    actionsVisible = "hover",
+    renderMarkdown,
+    className,
+    ...props
+  }, ref) => {
+    const [uncontrolledExpanded, setUncontrolledExpanded] = React.useState(defaultThinkingExpanded);
+    const isThinkingControlled = controlledThinkingExpanded !== void 0;
+    const thinkingExpanded = isThinkingControlled ? controlledThinkingExpanded : uncontrolledExpanded;
+    const toggleThinking = React.useCallback(() => {
+      const newValue = !thinkingExpanded;
+      if (isThinkingControlled) {
+        onThinkingExpandedChange?.(newValue);
+      } else {
+        setUncontrolledExpanded(newValue);
+      }
+    }, [thinkingExpanded, isThinkingControlled, onThinkingExpandedChange]);
+    const [isHovered, setIsHovered] = React.useState(false);
+    const elapsedTime = useThinkingTimer({
+      startTime: state.thinkingStartTime,
+      endTime: state.responseCompleteTime,
+      status: state.status
+    });
+    const totalTimeSeconds = React.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 showActionBar = state.status === "complete" && state.response;
+    const isActionBarVisible = actionsVisible === true || actionsVisible === "hover" && isHovered;
+    if (!hasAnyContent) {
+      return null;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        ref,
+        className,
+        onMouseEnter: () => setIsHovered(true),
+        onMouseLeave: () => setIsHovered(false),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border border-border rounded-lg overflow-hidden", children: [
+            showMetadataRow && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                MetadataRow,
+                {
+                  hasThinking: !!state.thinking,
+                  isExpanded: thinkingExpanded,
+                  onToggle: toggleThinking,
+                  toolCalls: state.toolCalls,
+                  knowledge: state.knowledge,
+                  memory: state.memory,
+                  status: state.status,
+                  elapsedTime
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                ThinkingSection,
+                {
+                  content: state.thinking,
+                  isExpanded: thinkingExpanded
+                }
+              )
+            ] }),
+            state.response && /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                className: core.cn(
+                  "bg-muted/50 p-4",
+                  showMetadataRow && "border-t border-border"
+                ),
+                children: renderMarkdown ? renderMarkdown(state.response) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "whitespace-pre-wrap", children: state.response })
+              }
+            )
+          ] }),
+          showActionBar && /* @__PURE__ */ jsxRuntime.jsx(
+            ActionBar,
+            {
+              response: state.response,
+              isVisible: isActionBarVisible,
+              totalTimeSeconds,
+              feedback,
+              onFeedbackChange,
+              onResponseCopy
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+AgentResponse.displayName = "AgentResponse";
+
+exports.ActionBar = ActionBar;
+exports.ActivityIndicators = ActivityIndicators;
+exports.AgentResponse = AgentResponse;
+exports.MetadataRow = MetadataRow;
+exports.ThinkingSection = ThinkingSection;
+exports.formatTime = formatTime;
+exports.formatTotalTime = formatTotalTime;
+exports.initialAgentResponseState = initialAgentResponseState;
+exports.useAgentResponseAccumulator = useAgentResponseAccumulator;
+exports.useThinkingTimer = useThinkingTimer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map