@agent-platform/ui 0.0.11 → 0.0.13

package/dist/index.js

@@ -1,2 +1,2462 @@
-import './styles/globals.css';
-export { AgentScreen } from './components/agent';
+import { createContext, useRef, useEffect, useState, useMemo, useCallback, useContext, useReducer } from 'react';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { CaretDown, Gear, Paperclip, PaperPlaneTilt } from '@phosphor-icons/react/dist/ssr';
+import { cva } from 'class-variance-authority';
+import { Slot } from 'radix-ui';
+import ReactMarkdown from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+import { createAuthClient } from 'better-auth/client';
+import { anonymousClient } from 'better-auth/client/plugins';
+
+// src/components/agent/agent-container.tsx
+
+// src/components/agent/agent-container-model.ts
+function resolveEffectiveInputProps({
+  sendMessage,
+  isLoading
+}) {
+  return {
+    onSend: sendMessage,
+    isLoading
+  };
+}
+function resolveAgentContainerLayoutState(input) {
+  const shouldShowMessages = input.messageCount > 0 || input.isLoading || input.hasError;
+  const shouldShowToolApprovalPanel = input.hasActiveApprovalRequest;
+  const shouldShowInput = !input.hasActiveApprovalRequest;
+  return {
+    shouldShowMessages,
+    shouldShowToolApprovalPanel,
+    shouldShowInput
+  };
+}
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+function AgentGreeting({
+  greeting = "\u3053\u3093\u306B\u3061\u306F \u{1F44B}",
+  subtext = "\u4F55\u304B\u304A\u624B\u4F1D\u3044\u3067\u304D\u308B\u3053\u3068\u306F\u3042\u308A\u307E\u3059\u304B\uFF1F",
+  className
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "agent-greeting",
+      className: cn("flex flex-col items-center gap-1.5 text-center", className),
+      children: [
+        /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: greeting }),
+        /* @__PURE__ */ jsx("p", { className: "text-lg font-semibold tracking-tight text-balance text-card-foreground", children: subtext })
+      ]
+    }
+  );
+}
+var buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline: "border bg-background hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-10 px-4 py-2 has-[>svg]:px-3",
+        xs: "h-6 gap-1 rounded-md px-2 text-xs has-[>svg]:px-1.5 [&_svg:not([class*='size-'])]:size-3",
+        sm: "h-9 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
+        lg: "h-11 rounded-md px-6 has-[>svg]:px-4",
+        icon: "size-10",
+        "icon-xs": "size-6 rounded-md [&_svg:not([class*='size-'])]:size-3",
+        "icon-sm": "size-8 rounded-md [&_svg:not([class*='size-'])]:size-4",
+        "icon-lg": "size-10 rounded-md [&_svg:not([class*='size-'])]:size-5"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  asChild = false,
+  ...props
+}) {
+  const Comp = asChild ? Slot.Root : "button";
+  return /* @__PURE__ */ jsx(
+    Comp,
+    {
+      "data-slot": "button",
+      "data-variant": variant,
+      "data-size": size,
+      className: cn(buttonVariants({ variant, size, className })),
+      ...props
+    }
+  );
+}
+function AgentHeader({
+  historyLabel = "\u5C65\u6B74",
+  onHistoryClick,
+  onSettingsClick,
+  onNewChatClick,
+  newChatLabel = "\u65B0\u898F\u30C1\u30E3\u30C3\u30C8",
+  settingsAriaLabel = "\u8A2D\u5B9A",
+  isHistoryOpen = false,
+  className
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "agent-header",
+      className: cn("flex w-full items-center justify-between bg-background px-4 py-2", className),
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            className: "flex items-center gap-1 rounded-md px-2 py-1 transition-colors hover:bg-muted",
+            onClick: onHistoryClick,
+            "aria-label": historyLabel,
+            "aria-expanded": isHistoryOpen,
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "text-sm font-semibold text-foreground", children: historyLabel }),
+              /* @__PURE__ */ jsx(
+                CaretDown,
+                {
+                  className: cn("size-4 transition-transform duration-200", isHistoryOpen && "rotate-180")
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "ghost",
+              size: "icon-sm",
+              onClick: onSettingsClick,
+              "aria-label": settingsAriaLabel,
+              className: "text-foreground",
+              children: /* @__PURE__ */ jsx(Gear, { className: "size-5" })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              onClick: onNewChatClick,
+              className: "bg-foreground text-background text-xs font-medium hover:bg-foreground/90",
+              children: newChatLabel
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/agent/history/format-timestamp.ts
+var MINUTE = 60 * 1e3;
+var HOUR = 60 * MINUTE;
+function isSameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function isYesterday(date, now) {
+  const yesterday = new Date(now);
+  yesterday.setDate(yesterday.getDate() - 1);
+  return isSameDay(date, yesterday);
+}
+function isWithinDays(date, now, days) {
+  const diff = now.getTime() - date.getTime();
+  return diff >= 0 && diff < days * 24 * HOUR;
+}
+function padTwo(n) {
+  return n.toString().padStart(2, "0");
+}
+function formatTime(date) {
+  return `${padTwo(date.getHours())}:${padTwo(date.getMinutes())}`;
+}
+var WEEKDAYS = ["\u65E5\u66DC\u65E5", "\u6708\u66DC\u65E5", "\u706B\u66DC\u65E5", "\u6C34\u66DC\u65E5", "\u6728\u66DC\u65E5", "\u91D1\u66DC\u65E5", "\u571F\u66DC\u65E5"];
+function formatRelativeTimestamp(updatedAt, now) {
+  const date = new Date(updatedAt);
+  if (Number.isNaN(date.getTime())) {
+    return updatedAt;
+  }
+  const ref = /* @__PURE__ */ new Date();
+  const diff = ref.getTime() - date.getTime();
+  if (diff < 0) {
+    return formatTime(date);
+  }
+  if (diff < MINUTE) {
+    return "\u305F\u3063\u305F\u4ECA";
+  }
+  if (diff < HOUR) {
+    return `${Math.floor(diff / MINUTE)}\u5206\u524D`;
+  }
+  if (isSameDay(date, ref)) {
+    return `\u4ECA\u65E5 ${formatTime(date)}`;
+  }
+  if (isYesterday(date, ref)) {
+    return `\u6628\u65E5 ${formatTime(date)}`;
+  }
+  if (isWithinDays(date, ref, 7)) {
+    return `${WEEKDAYS[date.getDay()]} ${formatTime(date)}`;
+  }
+  if (date.getFullYear() === ref.getFullYear()) {
+    return `${padTwo(date.getMonth() + 1)}/${padTwo(date.getDate())}`;
+  }
+  return `${date.getFullYear()}/${padTwo(date.getMonth() + 1)}/${padTwo(date.getDate())}`;
+}
+
+// src/components/agent/history/group-threads.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function startOfDay(date) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+var GROUP_LABELS = {
+  today: "\u4ECA\u65E5",
+  yesterday: "\u6628\u65E5",
+  thisWeek: "\u4ECA\u9031",
+  older: "\u305D\u308C\u4EE5\u524D"
+};
+var GROUP_ORDER = ["today", "yesterday", "thisWeek", "older"];
+function resolveGroupKey(updatedAt, now) {
+  const date = new Date(updatedAt);
+  if (Number.isNaN(date.getTime())) {
+    return "older";
+  }
+  const todayStart = startOfDay(now);
+  const yesterdayStart = new Date(todayStart.getTime() - DAY_MS);
+  const weekStart = new Date(todayStart.getTime() - 6 * DAY_MS);
+  if (date >= todayStart) {
+    return "today";
+  }
+  if (date >= yesterdayStart) {
+    return "yesterday";
+  }
+  if (date >= weekStart) {
+    return "thisWeek";
+  }
+  return "older";
+}
+function groupThreadsByDate(threads, now) {
+  const ref = /* @__PURE__ */ new Date();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const thread of threads) {
+    const key = resolveGroupKey(thread.updatedAt, ref);
+    const list = grouped.get(key) ?? [];
+    list.push(thread);
+    grouped.set(key, list);
+  }
+  return GROUP_ORDER.filter((key) => grouped.has(key)).map((key) => ({
+    label: GROUP_LABELS[key],
+    threads: grouped.get(key)
+  }));
+}
+function extractFirstLine(text) {
+  const line = text.split("\n").find((l) => l.trim().length > 0);
+  return line ? line.trim() : text.trim().split("\n")[0] ?? "";
+}
+function resolveThreadDisplayLabel(thread) {
+  if (thread.firstUserText && thread.firstUserText.trim().length > 0) {
+    return extractFirstLine(thread.firstUserText);
+  }
+  if (thread.title && thread.title.trim().length > 0) {
+    return extractFirstLine(thread.title);
+  }
+  return "\u65B0\u3057\u3044\u4F1A\u8A71";
+}
+function AgentHistoryDropdown({
+  threads,
+  isLoading,
+  error,
+  currentThreadId,
+  onSelect
+}) {
+  if (isLoading) {
+    return /* @__PURE__ */ jsx("div", { className: "absolute left-0 right-0 top-full z-30 mx-3 mt-1 max-w-sm rounded-lg border border-border bg-card shadow-xl", children: /* @__PURE__ */ jsx("p", { className: "px-3 py-4 text-sm text-muted-foreground", children: "\u5C65\u6B74\u3092\u8AAD\u307F\u8FBC\u307F\u4E2D..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx("div", { className: "absolute left-0 right-0 top-full z-30 mx-3 mt-1 rounded-lg border border-border bg-card shadow-xl", children: /* @__PURE__ */ jsx("p", { className: "px-3 py-4 text-sm text-red-600", children: error }) });
+  }
+  if (threads.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: "absolute left-0 right-0 top-full z-30 mx-3 mt-1 rounded-lg border border-border bg-card shadow-xl", children: /* @__PURE__ */ jsx("p", { className: "px-3 py-4 text-sm text-muted-foreground", children: "\u5C65\u6B74\u306F\u307E\u3060\u3042\u308A\u307E\u305B\u3093" }) });
+  }
+  const groups = groupThreadsByDate(threads);
+  return /* @__PURE__ */ jsx("div", { className: "absolute left-0 right-0 top-full z-30 mx-3 mt-1 max-h-[60vh] max-w-sm overflow-y-auto rounded-lg border border-border bg-card shadow-xl", children: groups.map((group) => /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx("div", { className: "sticky top-0 z-10 border-b border-border/50 bg-card/95 px-3 py-1.5 backdrop-blur-sm", children: /* @__PURE__ */ jsx("span", { className: "text-xs font-semibold text-muted-foreground", children: group.label }) }),
+    /* @__PURE__ */ jsx("ul", { className: "p-1", children: group.threads.map((thread) => {
+      const isActive = currentThreadId === thread.id;
+      return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          className: `w-full rounded-md px-3 py-2.5 text-left transition-colors ${isActive ? "border-l-2 border-l-primary bg-primary/5" : "hover:bg-muted/80"}`,
+          onClick: () => onSelect(thread.id),
+          children: [
+            /* @__PURE__ */ jsx("p", { className: "truncate text-sm font-medium text-foreground", children: resolveThreadDisplayLabel(thread) }),
+            /* @__PURE__ */ jsx("p", { className: "mt-0.5 text-xs text-muted-foreground", children: formatRelativeTimestamp(thread.updatedAt) })
+          ]
+        }
+      ) }, thread.id);
+    }) })
+  ] }, group.label)) });
+}
+function Textarea({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "textarea",
+    {
+      "data-slot": "textarea",
+      className: cn(
+        "border-input placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 flex field-sizing-content min-h-16 w-full rounded-md border bg-transparent px-3 py-2 text-base outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function AgentInput({
+  value: controlledValue,
+  onChange,
+  onSend,
+  onAttach,
+  placeholder = "AI\u306B\u76F8\u8AC7\u3057\u3066\u307F\u307E\u3057\u3087\u3046",
+  disabled = false,
+  isLoading = false,
+  className
+}) {
+  const [uncontrolledValue, setUncontrolledValue] = useState("");
+  const textareaRef = useRef(null);
+  const isControlled = controlledValue !== void 0;
+  const value = isControlled ? controlledValue : uncontrolledValue;
+  const resetTextareaHeight = useCallback(() => {
+    if (textareaRef.current) {
+      textareaRef.current.style.height = "auto";
+    }
+  }, []);
+  const adjustTextareaHeight = useCallback(() => {
+    const textarea = textareaRef.current;
+    if (textarea) {
+      textarea.style.height = "auto";
+      textarea.style.height = `${Math.min(textarea.scrollHeight, 160)}px`;
+    }
+  }, []);
+  const handleChange = useCallback(
+    (e) => {
+      const newValue = e.target.value;
+      if (!isControlled) {
+        setUncontrolledValue(newValue);
+      }
+      onChange?.(newValue);
+      adjustTextareaHeight();
+    },
+    [isControlled, onChange, adjustTextareaHeight]
+  );
+  const handleSend = useCallback(() => {
+    if (value.trim() && !disabled && !isLoading) {
+      onSend?.(value.trim());
+      if (!isControlled) {
+        setUncontrolledValue("");
+      }
+      resetTextareaHeight();
+    }
+  }, [value, disabled, isLoading, onSend, isControlled, resetTextareaHeight]);
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+        e.preventDefault();
+        handleSend();
+      }
+    },
+    [handleSend]
+  );
+  const canSend = value.trim().length > 0 && !disabled && !isLoading;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "agent-input",
+      className: cn("w-full border-t border-border bg-muted px-3 pb-3 pt-2", className),
+      children: /* @__PURE__ */ jsxs("div", { className: "flex items-end gap-1 p-2 rounded-lg border border-border bg-background transition-colors", children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            variant: "ghost",
+            size: "icon-sm",
+            onClick: onAttach,
+            disabled,
+            "aria-label": "\u30D5\u30A1\u30A4\u30EB\u3092\u6DFB\u4ED8",
+            className: "mb-0.5 text-muted-foreground hover:text-foreground",
+            children: /* @__PURE__ */ jsx(Paperclip, { className: "size-4", weight: "bold" })
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Textarea,
+          {
+            ref: textareaRef,
+            value,
+            onChange: handleChange,
+            onKeyDown: handleKeyDown,
+            placeholder,
+            disabled,
+            rows: 1,
+            className: "border-none p-1 resize-none min-h-8 focus-visible:ring-0 focus-visible:border-0 bg-transparent"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            size: "icon-sm",
+            onClick: handleSend,
+            disabled: !canSend,
+            "aria-label": "\u9001\u4FE1 (\u2318+Enter)",
+            children: /* @__PURE__ */ jsx(PaperPlaneTilt, { className: "size-5", weight: "fill" })
+          }
+        )
+      ] })
+    }
+  );
+}
+var listItemPattern = /^\s*(?:[-*+]\s+|\d+[.)]\s+)/;
+var codeFenceStartPattern = /^\s*```/;
+var blockquotePattern = /^\s*>/;
+function isListItemLine(line) {
+  return listItemPattern.test(line);
+}
+function isPotentialParagraphLine(line) {
+  if (!line.trim()) return false;
+  if (/^(?: {4,}|\t)/.test(line)) return false;
+  const normalizedLine = line.replace(/^[ \u3000]+/, "");
+  if (!normalizedLine) return false;
+  if (isListItemLine(normalizedLine)) return false;
+  if (blockquotePattern.test(normalizedLine)) return false;
+  if (codeFenceStartPattern.test(normalizedLine)) return false;
+  return true;
+}
+function normalizeAgentMarkdown(content) {
+  const lines = content.replace(/\r\n?/g, "\n").split("\n");
+  const normalized = [];
+  for (const line of lines) {
+    const prevLine = normalized[normalized.length - 1] ?? "";
+    if (isListItemLine(prevLine) && isPotentialParagraphLine(line)) {
+      normalized.push("");
+    }
+    normalized.push(line);
+  }
+  return normalized.join("\n");
+}
+var components = {
+  pre: ({ children }) => /* @__PURE__ */ jsx("pre", { className: "bg-background/50 rounded p-2 overflow-x-auto my-1.5 text-xs", children }),
+  code: ({ children, className }) => {
+    if (className) {
+      return /* @__PURE__ */ jsx("code", { className: cn("text-xs", className), children });
+    }
+    return /* @__PURE__ */ jsx("code", { className: "bg-background/50 px-1 py-0.5 rounded text-xs", children });
+  },
+  a: ({ href, children }) => /* @__PURE__ */ jsx(
+    "a",
+    {
+      href,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      className: "text-primary underline hover:text-primary/80",
+      children
+    }
+  ),
+  ul: ({ children }) => /* @__PURE__ */ jsx("ul", { className: "list-disc list-inside pl-3 my-1", children }),
+  ol: ({ children }) => /* @__PURE__ */ jsx("ol", { className: "list-decimal list-inside pl-3 my-1", children }),
+  li: ({ children }) => /* @__PURE__ */ jsx("li", { className: "leading-relaxed", children }),
+  p: ({ children }) => /* @__PURE__ */ jsx("p", { className: "first:mt-0 last:mb-0", children }),
+  h1: ({ children }) => /* @__PURE__ */ jsx("h1", { className: "text-base font-bold mt-3 mb-1 first:mt-0", children }),
+  h2: ({ children }) => /* @__PURE__ */ jsx("h2", { className: "text-sm font-bold mt-2.5 mb-1 first:mt-0", children }),
+  h3: ({ children }) => /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold mt-2 mb-1 first:mt-0", children }),
+  blockquote: ({ children }) => /* @__PURE__ */ jsx("blockquote", { className: "border-l-2 border-border pl-3 my-1.5 text-muted-foreground italic", children }),
+  table: ({ children }) => /* @__PURE__ */ jsx("div", { className: "overflow-x-auto my-1.5", children: /* @__PURE__ */ jsx("table", { className: "min-w-full border-collapse border border-border text-xs", children }) }),
+  thead: ({ children }) => /* @__PURE__ */ jsx("thead", { className: "bg-muted/50", children }),
+  th: ({ children }) => /* @__PURE__ */ jsx("th", { className: "border border-border px-2 py-1.5 text-left font-semibold", children }),
+  td: ({ children }) => /* @__PURE__ */ jsx("td", { className: "border border-border px-2 py-1.5", children }),
+  hr: () => /* @__PURE__ */ jsx("hr", { className: "my-3 border-border" })
+};
+function Markdown({ content, className }) {
+  const normalizedContent = normalizeAgentMarkdown(content);
+  return /* @__PURE__ */ jsx("div", { className: cn("text-sm leading-relaxed", className), children: /* @__PURE__ */ jsx(ReactMarkdown, { remarkPlugins: [remarkGfm], components, children: normalizedContent }) });
+}
+var defaultStatusLabels = {
+  pending: "\u5F85\u6A5F\u4E2D",
+  "awaiting-approval": "\u627F\u8A8D\u5F85\u3061",
+  executing: "\u5B9F\u884C\u4E2D",
+  completed: "\u5B8C\u4E86",
+  error: "\u30A8\u30E9\u30FC"
+};
+var statusColors = {
+  pending: "bg-muted text-muted-foreground",
+  "awaiting-approval": "bg-amber-50 text-amber-700 dark:bg-amber-950 dark:text-amber-300",
+  executing: "bg-primary/10 text-primary",
+  completed: "bg-green-50 text-green-600 dark:bg-green-950 dark:text-green-400",
+  error: "bg-destructive/10 text-destructive"
+};
+function ToolCallCard({
+  toolCallState,
+  statusLabels,
+  parametersLabel = "\u30D1\u30E9\u30E1\u30FC\u30BF",
+  resultLabel = "\u7D50\u679C\u3092\u8868\u793A"
+}) {
+  const { toolCall, status, result, error } = toolCallState;
+  const toolLabel = toolCall.toolName;
+  const mergedStatusLabels = statusLabels ? { ...defaultStatusLabels, ...statusLabels } : defaultStatusLabels;
+  const statusLabel = mergedStatusLabels[status];
+  return /* @__PURE__ */ jsxs("div", { className: "rounded-md p-1 mt-3 bg-card", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-xs font-medium text-foreground", children: toolLabel }),
+      status === "executing" ? /* @__PURE__ */ jsx("div", { className: "h-3 w-3 animate-spin rounded-full border border-primary border-t-transparent" }) : /* @__PURE__ */ jsx("span", { className: cn("rounded-full px-2 py-0.5 text-[11px]", statusColors[status]), children: statusLabel })
+    ] }),
+    /* @__PURE__ */ jsxs("details", { className: "mt-2", children: [
+      /* @__PURE__ */ jsx("summary", { className: "cursor-pointer text-xs text-muted-foreground", children: parametersLabel }),
+      /* @__PURE__ */ jsx("pre", { className: "mt-1 ml-4 overflow-x-auto rounded bg-muted p-2 text-xs text-muted-foreground", children: JSON.stringify(toolCall.input, null, 2) })
+    ] }),
+    status === "completed" && result !== void 0 && /* @__PURE__ */ jsxs("details", { className: "mt-2", children: [
+      /* @__PURE__ */ jsx("summary", { className: "cursor-pointer text-xs text-muted-foreground", children: resultLabel }),
+      /* @__PURE__ */ jsx("pre", { className: "mt-1 ml-4 max-h-40 overflow-auto rounded bg-muted p-2 text-xs text-muted-foreground", children: typeof result === "string" ? result : JSON.stringify(result, null, 2) })
+    ] }),
+    status === "error" && error && /* @__PURE__ */ jsx("div", { className: "mt-2 rounded bg-destructive/10 p-2 text-xs text-destructive", children: error })
+  ] });
+}
+
+// src/components/agent/message/utils.ts
+function extractTextContent(content) {
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function extractToolCalls(content) {
+  return content.filter((part) => part.type === "tool-call").map((part) => part.toolCall);
+}
+function shouldShowLoadingIndicator({
+  messages,
+  isLoading
+}) {
+  if (!isLoading) return false;
+  const lastMessage = messages[messages.length - 1];
+  const hasNoMessages = messages.length === 0;
+  if (hasNoMessages) return true;
+  const lastAssistantHasContent = lastMessage?.role === "assistant" && extractTextContent(lastMessage.content).trim().length > 0;
+  return lastMessage?.role === "user" || !lastAssistantHasContent;
+}
+function MessageItem({ message, pendingToolCalls }) {
+  const isUser = message.role === "user";
+  const textContent = extractTextContent(message.content);
+  const toolCalls = extractToolCalls(message.content);
+  if (!isUser && message.isStreaming && !textContent && toolCalls.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx("div", { className: cn("flex", isUser ? "justify-end" : "justify-start"), children: /* @__PURE__ */ jsxs("div", { className: "max-w-3/4 space-y-1.5", children: [
+    textContent && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: cn(
+          "rounded-lg px-3 py-2",
+          isUser ? "bg-muted text-foreground" : "border border-border bg-card text-card-foreground"
+        ),
+        children: isUser ? /* @__PURE__ */ jsx("div", { className: "whitespace-pre-wrap text-sm leading-relaxed", children: textContent }) : /* @__PURE__ */ jsx(Markdown, { content: textContent })
+      }
+    ),
+    !isUser && toolCalls.length > 0 && /* @__PURE__ */ jsx("div", { className: "ml-2 space-y-1.5 border-l-2 border-border pl-2", children: toolCalls.map((tc) => {
+      const toolCallState = pendingToolCalls.find(
+        (p) => p.toolCall.toolCallId === tc.toolCallId
+      );
+      if (toolCallState) {
+        return /* @__PURE__ */ jsx(
+          ToolCallCard,
+          {
+            toolCallState
+          },
+          tc.toolCallId
+        );
+      }
+      return null;
+    }) })
+  ] }) });
+}
+function LoadingDots() {
+  return /* @__PURE__ */ jsxs("span", { className: "flex gap-0.5", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx("span", { className: "h-0.5 w-0.5 animate-dot-fade rounded-full bg-muted-foreground/50 [animation-delay:0ms]" }),
+    /* @__PURE__ */ jsx("span", { className: "h-0.5 w-0.5 animate-dot-fade rounded-full bg-muted-foreground/50 [animation-delay:150ms]" }),
+    /* @__PURE__ */ jsx("span", { className: "h-0.5 w-0.5 animate-dot-fade rounded-full bg-muted-foreground/50 [animation-delay:300ms]" })
+  ] });
+}
+function MessageLoading({ className }) {
+  return /* @__PURE__ */ jsx("output", { className: cn("flex justify-start", className), "aria-label": "AI\u5FDC\u7B54\u3092\u5F85\u6A5F\u4E2D", children: /* @__PURE__ */ jsx("div", { className: "max-w-xl", children: /* @__PURE__ */ jsx("div", { className: "rounded-lg border border-border bg-card px-3 py-2", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+    /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground", children: "\u8003\u3048\u4E2D" }),
+    /* @__PURE__ */ jsx(LoadingDots, {})
+  ] }) }) }) });
+}
+function MessageList({
+  messages,
+  pendingToolCalls,
+  isLoading = false
+}) {
+  const bottomRef = useRef(null);
+  useEffect(() => {
+    bottomRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages, isLoading]);
+  if (messages.length === 0 && !isLoading) {
+    return null;
+  }
+  const showLoadingIndicator = shouldShowLoadingIndicator({
+    messages,
+    isLoading
+  });
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3 p-3", children: [
+    messages.map((message) => /* @__PURE__ */ jsx(
+      MessageItem,
+      {
+        message,
+        pendingToolCalls
+      },
+      message.id
+    )),
+    showLoadingIndicator && /* @__PURE__ */ jsx(MessageLoading, {}),
+    /* @__PURE__ */ jsx("div", { ref: bottomRef })
+  ] });
+}
+
+// src/components/agent/approval-ui-model.ts
+var DEFAULT_TOOL_APPROVAL_LABELS = {
+  title: "\u3053\u306E\u64CD\u4F5C\u3092\u5B9F\u884C\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3057\u3087\u3046\u304B\uFF1F",
+  approveButton: "\u5B9F\u884C\u3059\u308B",
+  rejectButton: "\u5B9F\u884C\u3057\u306A\u3044"
+};
+function resolveToolApprovalLabels(toolApprovalLabels) {
+  if (!toolApprovalLabels) {
+    return DEFAULT_TOOL_APPROVAL_LABELS;
+  }
+  return {
+    title: toolApprovalLabels.title ?? DEFAULT_TOOL_APPROVAL_LABELS.title,
+    approveButton: toolApprovalLabels.approveButton ?? DEFAULT_TOOL_APPROVAL_LABELS.approveButton,
+    rejectButton: toolApprovalLabels.rejectButton ?? DEFAULT_TOOL_APPROVAL_LABELS.rejectButton
+  };
+}
+function resolveToolApprovalPanelState(activeApprovalRequest) {
+  if (!activeApprovalRequest) {
+    return {
+      isActionable: false
+    };
+  }
+  return {
+    actionLabel: activeApprovalRequest.actionLabel,
+    isActionable: true
+  };
+}
+function ToolApprovalPanel({
+  activeApprovalRequest,
+  approveToolCall,
+  rejectToolCall,
+  toolApprovalLabels
+}) {
+  const approvalLabels = resolveToolApprovalLabels(toolApprovalLabels);
+  const panelState = resolveToolApprovalPanelState(activeApprovalRequest);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "agent-tool-approval",
+      className: "w-full border-t border-border bg-muted px-3 pb-3 pt-2",
+      children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          "data-state": panelState.isActionable ? "actionable" : "idle",
+          className: cn(
+            "flex flex-col gap-2 rounded-lg border border-border bg-primary-foreground p-3 shadow-sm",
+            !panelState.isActionable && "opacity-75"
+          ),
+          children: [
+            /* @__PURE__ */ jsx("div", { className: "text-sm font-bold text-foreground text-balance", children: approvalLabels.title }),
+            /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2 pt-1", children: [
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  type: "button",
+                  variant: "outline",
+                  onClick: approveToolCall,
+                  disabled: !panelState.isActionable,
+                  className: "justify-start",
+                  children: approvalLabels.approveButton
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  type: "button",
+                  variant: "outline",
+                  onClick: rejectToolCall,
+                  disabled: !panelState.isActionable,
+                  className: "justify-start",
+                  children: approvalLabels.rejectButton
+                }
+              )
+            ] })
+          ]
+        }
+      )
+    }
+  );
+}
+function AgentContainerView({
+  onNewChatClick,
+  onHistoryClick,
+  onHistorySelect,
+  isHistoryOpen = false,
+  historyThreads,
+  isHistoryLoading,
+  historyError,
+  currentThreadId,
+  historyAreaRef,
+  inputProps,
+  className,
+  messages,
+  pendingToolCalls,
+  activeApprovalRequest,
+  approveToolCall,
+  rejectToolCall,
+  toolApprovalLabels,
+  isLoading,
+  error
+}) {
+  const layoutState = resolveAgentContainerLayoutState({
+    messageCount: messages.length,
+    isLoading,
+    hasActiveApprovalRequest: Boolean(activeApprovalRequest),
+    hasError: Boolean(error)
+  });
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "agent-container",
+      className: cn("flex h-full w-full flex-col mx-auto max-w-[1120px]", className),
+      children: [
+        /* @__PURE__ */ jsxs("div", { ref: historyAreaRef, className: "relative", children: [
+          /* @__PURE__ */ jsx(
+            AgentHeader,
+            {
+              onNewChatClick,
+              onHistoryClick,
+              isHistoryOpen
+            }
+          ),
+          isHistoryOpen && /* @__PURE__ */ jsx(
+            AgentHistoryDropdown,
+            {
+              threads: historyThreads,
+              isLoading: isHistoryLoading,
+              error: historyError,
+              currentThreadId,
+              onSelect: onHistorySelect ?? (() => void 0)
+            }
+          )
+        ] }),
+        layoutState.shouldShowMessages ? /* @__PURE__ */ jsxs("div", { className: "flex-1 overflow-y-auto bg-white pb-[97px]", children: [
+          /* @__PURE__ */ jsx(
+            MessageList,
+            {
+              messages,
+              pendingToolCalls,
+              isLoading
+            }
+          ),
+          error && /* @__PURE__ */ jsx("div", { className: "mx-4 mb-4 rounded-lg bg-red-50 p-3 text-sm text-red-600", children: error })
+        ] }) : /* @__PURE__ */ jsx("div", { className: "flex flex-1 flex-col items-center justify-center gap-6 bg-background px-4 py-4", children: /* @__PURE__ */ jsx(AgentGreeting, {}) }),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "fixed bottom-0 left-0 right-0 mx-auto w-full max-w-[1120px] bg-background",
+            children: [
+              layoutState.shouldShowInput && /* @__PURE__ */ jsx(AgentInput, { ...inputProps }),
+              layoutState.shouldShowToolApprovalPanel && /* @__PURE__ */ jsx(
+                ToolApprovalPanel,
+                {
+                  activeApprovalRequest,
+                  approveToolCall,
+                  rejectToolCall,
+                  toolApprovalLabels
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+var AgentContext = createContext(null);
+function useOptionalAgentContext() {
+  return useContext(AgentContext);
+}
+function AgentContainer({ className }) {
+  const context = useOptionalAgentContext();
+  const messages = context?.messages ?? [];
+  const pendingToolCalls = context?.pendingToolCalls ?? [];
+  const activeApprovalRequest = context?.activeApprovalRequest ?? null;
+  const approveToolCall = context?.approveToolCall ?? (() => void 0);
+  const rejectToolCall = context?.rejectToolCall ?? (() => void 0);
+  const toolApprovalLabels = context?.config.toolApprovalLabels;
+  const error = context?.error ?? null;
+  const isLoading = context?.isLoading ?? false;
+  const historyThreads = context?.historyThreads ?? [];
+  const isHistoryLoading = context?.isHistoryLoading ?? false;
+  const historyError = context?.historyError ?? null;
+  const loadHistoryThreads = context?.loadHistoryThreads;
+  const loadThreadMessages = context?.loadThreadMessages;
+  const sendMessage = context?.sendMessage;
+  const onNewChatClick = context?.clearChat;
+  const currentThreadId = context?.threadId ?? null;
+  const [isHistoryOpen, setIsHistoryOpen] = useState(false);
+  const historyAreaRef = useRef(null);
+  const effectiveInputProps = useMemo(
+    () => resolveEffectiveInputProps({ sendMessage, isLoading }),
+    [sendMessage, isLoading]
+  );
+  const onHistoryClick = useCallback(() => {
+    if (!isHistoryOpen) {
+      void loadHistoryThreads?.();
+    }
+    setIsHistoryOpen((prev) => !prev);
+  }, [isHistoryOpen, loadHistoryThreads]);
+  const onHistorySelect = useCallback(
+    (threadId) => {
+      void loadThreadMessages?.(threadId);
+      setIsHistoryOpen(false);
+    },
+    [loadThreadMessages]
+  );
+  useEffect(() => {
+    if (!isHistoryOpen) return;
+    function handleClickOutside(event) {
+      if (historyAreaRef.current && !historyAreaRef.current.contains(event.target)) {
+        setIsHistoryOpen(false);
+      }
+    }
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, [isHistoryOpen]);
+  return /* @__PURE__ */ jsx(
+    AgentContainerView,
+    {
+      onNewChatClick,
+      onHistoryClick,
+      isHistoryOpen,
+      historyThreads,
+      isHistoryLoading,
+      historyError,
+      currentThreadId,
+      onHistorySelect,
+      historyAreaRef,
+      inputProps: effectiveInputProps,
+      className,
+      messages,
+      pendingToolCalls,
+      activeApprovalRequest,
+      approveToolCall,
+      rejectToolCall,
+      toolApprovalLabels,
+      isLoading,
+      error
+    }
+  );
+}
+function createAgentAuthClient(agentServerUrl) {
+  const baseURL = agentServerUrl.replace(/\/api\/agent\/?$/, "");
+  return createAuthClient({
+    baseURL,
+    basePath: "/api/auth",
+    plugins: [anonymousClient()]
+  });
+}
+
+// src/modules/agent/auth/use-agent-auth.ts
+function useAgentAuth(agentServerUrl) {
+  const client = useMemo(() => createAgentAuthClient(agentServerUrl), [agentServerUrl]);
+  const [isReady, setIsReady] = useState(false);
+  const [error, setError] = useState(null);
+  const [userId, setUserId] = useState(null);
+  const tokenRef = useRef("");
+  useEffect(() => {
+    let cancelled = false;
+    let timeoutId;
+    async function init() {
+      try {
+        const sessionResult = await client.getSession();
+        if (cancelled) return;
+        if (sessionResult.data?.session) {
+          tokenRef.current = sessionResult.data.session.token;
+          setUserId(sessionResult.data.user.id);
+          setError(null);
+          setIsReady(true);
+          return;
+        }
+        const signInResult = await client.signIn.anonymous();
+        if (cancelled) return;
+        if (signInResult.error) {
+          setError(signInResult.error.message ?? "Anonymous sign-in failed");
+          setIsReady(true);
+          return;
+        }
+        if (signInResult.data) {
+          tokenRef.current = signInResult.data.token ?? "";
+          setUserId(signInResult.data.user?.id ?? null);
+        }
+        setError(null);
+        setIsReady(true);
+      } catch (e) {
+        if (cancelled) return;
+        setError(e instanceof Error ? e.message : "Auth initialization failed");
+        setIsReady(true);
+      } finally {
+        if (timeoutId !== void 0) {
+          clearTimeout(timeoutId);
+        }
+      }
+    }
+    timeoutId = setTimeout(() => {
+      if (!cancelled) {
+        setError("Auth initialization timed out");
+        setIsReady(true);
+      }
+    }, 1e4);
+    init();
+    return () => {
+      cancelled = true;
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [client]);
+  const getToken = useCallback(async () => {
+    try {
+      const sessionResult = await client.getSession();
+      if (sessionResult.data?.session?.token) {
+        tokenRef.current = sessionResult.data.session.token;
+      }
+    } catch {
+    }
+    return tokenRef.current;
+  }, [client]);
+  return { isReady, error, userId, getToken };
+}
+
+// src/modules/agent/agent.repository.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readRecord(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  return value;
+}
+function readString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return void 0;
+}
+function readNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  return void 0;
+}
+function readArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return void 0;
+}
+function isAgentStreamEvent(value) {
+  const event = readRecord(value);
+  if (!event) {
+    return false;
+  }
+  const type = readString(event.type);
+  const payload = readRecord(event.payload);
+  if (!type || !payload) {
+    return false;
+  }
+  if (type === "text-delta") {
+    return typeof payload.text === "string";
+  }
+  if (type === "tool-intent") {
+    return typeof payload.toolCallId === "string" && typeof payload.toolName === "string";
+  }
+  if (type === "tool-call") {
+    return typeof payload.toolCallId === "string" && typeof payload.toolName === "string";
+  }
+  if (type === "tool-result") {
+    return typeof payload.toolCallId === "string";
+  }
+  if (type === "finish") {
+    return true;
+  }
+  if (type === "error") {
+    return typeof payload.error === "string";
+  }
+  if (type === "thread-id") {
+    return typeof payload.threadId === "string";
+  }
+  if (type === "agent-id") {
+    return typeof payload.agentId === "string";
+  }
+  return false;
+}
+function parseSSEBuffer(buffer) {
+  const events = [];
+  const lines = buffer.split("\n");
+  const remaining = lines.pop() || "";
+  for (const line of lines) {
+    if (!line.startsWith("data: ")) {
+      continue;
+    }
+    const jsonString = line.slice(6);
+    if (!jsonString) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(jsonString);
+      if (isAgentStreamEvent(parsed)) {
+        events.push(parsed);
+      }
+    } catch (error) {
+      console.warn("Failed to parse SSE event:", error);
+    }
+  }
+  return { events, remaining };
+}
+function buildToolEndpointRequest(toolCall, apiBaseUrl) {
+  if (!toolCall.apiRequest) {
+    return null;
+  }
+  const { apiRequest, input } = toolCall;
+  const inputData = readRecord(input) ?? {};
+  const method = apiRequest.method.toUpperCase();
+  let path = apiRequest.path;
+  const usedParams = /* @__PURE__ */ new Set();
+  for (const paramName of apiRequest.pathParams) {
+    const value = inputData[paramName];
+    if (value === void 0) {
+      continue;
+    }
+    path = path.replace(`{${paramName}}`, encodeURIComponent(String(value)));
+    usedParams.add(paramName);
+  }
+  const queryParams = {};
+  const bodyData = {};
+  for (const key of apiRequest.queryParams) {
+    const value = inputData[key];
+    if (value === void 0) {
+      continue;
+    }
+    queryParams[key] = String(value);
+    usedParams.add(key);
+  }
+  for (const key of apiRequest.bodyFields) {
+    const value = inputData[key];
+    if (value === void 0) {
+      continue;
+    }
+    bodyData[key] = value;
+    usedParams.add(key);
+  }
+  for (const [key, value] of Object.entries(inputData)) {
+    if (usedParams.has(key) || value === void 0) {
+      continue;
+    }
+    if (method === "GET" || method === "DELETE") {
+      queryParams[key] = String(value);
+      continue;
+    }
+    bodyData[key] = value;
+  }
+  const queryString = new URLSearchParams(queryParams).toString();
+  return {
+    method,
+    url: `${apiBaseUrl}${path}${queryString ? `?${queryString}` : ""}`,
+    bodyData
+  };
+}
+function normalizeThreadSummary(thread) {
+  const threadRecord = readRecord(thread);
+  if (!threadRecord) {
+    return null;
+  }
+  const id = readString(threadRecord.id);
+  const resourceId = readString(threadRecord.resourceId);
+  const createdAt = readString(threadRecord.createdAt);
+  const updatedAt = readString(threadRecord.updatedAt);
+  if (!id || !resourceId || !createdAt || !updatedAt) {
+    return null;
+  }
+  return {
+    id,
+    resourceId,
+    title: readString(threadRecord.title),
+    createdAt,
+    updatedAt,
+    firstUserText: readString(threadRecord.firstUserText)
+  };
+}
+function normalizeListThreadsResponse(body) {
+  const bodyRecord = readRecord(body) ?? {};
+  const threadValues = readArray(bodyRecord.threads);
+  const threads = threadValues ? threadValues.map((thread) => normalizeThreadSummary(thread)).filter((thread) => Boolean(thread)) : [];
+  const page = readNumber(bodyRecord.page) ?? 0;
+  const perPage = readNumber(bodyRecord.perPage) ?? threads.length;
+  const total = readNumber(bodyRecord.total) ?? threads.length;
+  return {
+    threads,
+    page,
+    perPage,
+    hasMore: Boolean(bodyRecord.hasMore),
+    total
+  };
+}
+function normalizeMessagePart(part) {
+  const partRecord = readRecord(part);
+  if (!partRecord) {
+    return null;
+  }
+  const partType = readString(partRecord.type);
+  if (!partType) {
+    return null;
+  }
+  if (partType === "text" || partType === "input_text") {
+    const text = readString(partRecord.text);
+    if (text === void 0) {
+      return null;
+    }
+    return { type: "text", text };
+  }
+  if (partType === "tool-call") {
+    const toolCallRecord = readRecord(partRecord.toolCall);
+    if (!toolCallRecord) {
+      return null;
+    }
+    const toolCallId = readString(toolCallRecord.toolCallId);
+    const toolName = readString(toolCallRecord.toolName);
+    if (!toolCallId || !toolName) {
+      return null;
+    }
+    return {
+      type: "tool-call",
+      toolCall: {
+        toolCallId,
+        toolName,
+        input: toolCallRecord.input
+      }
+    };
+  }
+  if (partType === "tool-result") {
+    const toolResultRecord = readRecord(partRecord.toolResult);
+    if (!toolResultRecord) {
+      return null;
+    }
+    const toolCallId = readString(toolResultRecord.toolCallId);
+    if (!toolCallId) {
+      return null;
+    }
+    return {
+      type: "tool-result",
+      toolResult: {
+        toolCallId,
+        result: toolResultRecord.result,
+        isError: typeof toolResultRecord.isError === "boolean" ? toolResultRecord.isError : void 0
+      }
+    };
+  }
+  return null;
+}
+function normalizeMessageContent(content) {
+  if (typeof content === "string") {
+    return content.length > 0 ? [{ type: "text", text: content }] : null;
+  }
+  const contentValues = readArray(content);
+  if (!contentValues) {
+    return null;
+  }
+  const normalizedParts = [];
+  for (const part of contentValues) {
+    const normalizedPart = normalizeMessagePart(part);
+    if (!normalizedPart) {
+      continue;
+    }
+    normalizedParts.push(normalizedPart);
+  }
+  return normalizedParts.length > 0 ? normalizedParts : null;
+}
+function normalizeThreadMessage(message) {
+  const messageRecord = readRecord(message);
+  if (!messageRecord) {
+    return null;
+  }
+  const id = readString(messageRecord.id);
+  const role = readString(messageRecord.role);
+  const isSupportedRole = role === "user" || role === "assistant";
+  if (!id || !isSupportedRole) {
+    return null;
+  }
+  const content = normalizeMessageContent(messageRecord.content);
+  if (!content) {
+    return null;
+  }
+  return {
+    id,
+    role,
+    content
+  };
+}
+function normalizeGetThreadMessagesResponse(body) {
+  const bodyRecord = readRecord(body) ?? {};
+  const messageValues = readArray(bodyRecord.messages);
+  const messages = messageValues ? messageValues.map((message) => normalizeThreadMessage(message)).filter(
+    (message) => Boolean(message)
+  ) : [];
+  const threadId = readString(bodyRecord.threadId) ?? "";
+  const page = readNumber(bodyRecord.page) ?? 0;
+  const perPage = readNumber(bodyRecord.perPage) ?? messages.length;
+  const total = readNumber(bodyRecord.total) ?? messages.length;
+  return {
+    threadId,
+    messages,
+    page,
+    perPage,
+    hasMore: Boolean(bodyRecord.hasMore),
+    total
+  };
+}
+function createAgentRepository(options) {
+  const { fetchFn = fetch, getAuthToken, disableToolApiAuthHeader = true } = options;
+  const resolveToken = async () => {
+    return getAuthToken ? getAuthToken() : void 0;
+  };
+  return {
+    buildAgentHeaders: async (getAgentHeaders) => {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const token = await resolveToken();
+      if (token) {
+        headers.Authorization = token.startsWith("Bearer ") ? token : `Bearer ${token}`;
+      }
+      const customHeaders = getAgentHeaders ? await getAgentHeaders() : void 0;
+      if (!customHeaders) {
+        return headers;
+      }
+      for (const [key, value] of Object.entries(customHeaders)) {
+        if (value) {
+          headers[key] = value;
+        }
+      }
+      return headers;
+    },
+    buildToolApiHeaders: async () => {
+      const headers = {};
+      if (disableToolApiAuthHeader) {
+        return headers;
+      }
+      const token = await resolveToken();
+      if (!token) {
+        return headers;
+      }
+      headers.Authorization = token.startsWith("Bearer ") ? token : `Bearer ${token}`;
+      return headers;
+    },
+    sendChat: async ({ agentServerUrl, threadId, message, appId, agentId, headers, signal }) => {
+      return fetchFn(`${agentServerUrl}/chat`, {
+        method: "POST",
+        headers,
+        credentials: "include",
+        body: JSON.stringify({ threadId, message, appId, ...agentId && { agentId } }),
+        signal
+      });
+    },
+    continueChat: async ({ agentServerUrl, payload, headers, signal }) => {
+      return fetchFn(`${agentServerUrl}/chat/tool-result`, {
+        method: "POST",
+        headers,
+        credentials: "include",
+        body: JSON.stringify(payload),
+        signal
+      });
+    },
+    listThreads: async ({ agentServerUrl, headers, agentId, appId, signal }) => {
+      const params = new URLSearchParams();
+      if (agentId) {
+        params.set("agentId", agentId);
+      } else if (appId) {
+        params.set("appId", appId);
+      }
+      return fetchFn(`${agentServerUrl}/chat/threads?${params.toString()}`, {
+        method: "GET",
+        headers,
+        credentials: "include",
+        signal
+      });
+    },
+    getThreadMessages: async ({ agentServerUrl, headers, threadId, agentId, appId, signal }) => {
+      const params = new URLSearchParams();
+      if (agentId) {
+        params.set("agentId", agentId);
+      } else if (appId) {
+        params.set("appId", appId);
+      }
+      return fetchFn(`${agentServerUrl}/chat/threads/${encodeURIComponent(threadId)}/messages?${params.toString()}`, {
+        method: "GET",
+        headers,
+        credentials: "include",
+        signal
+      });
+    },
+    collectStreamEvents: async (response, options2) => {
+      const reader = response.body?.getReader();
+      if (!reader) {
+        return [];
+      }
+      const decoder = new TextDecoder();
+      const events = [];
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const parsed = parseSSEBuffer(buffer);
+          buffer = parsed.remaining;
+          events.push(...parsed.events);
+          if (parsed.events.length > 0) {
+            options2?.onEvents?.(parsed.events);
+          }
+        }
+        if (buffer.startsWith("data: ")) {
+          try {
+            const parsed = JSON.parse(buffer.slice(6));
+            if (isAgentStreamEvent(parsed)) {
+              events.push(parsed);
+              options2?.onEvents?.([parsed]);
+            }
+          } catch (error) {
+            console.warn("Failed to parse remaining SSE event:", error);
+          }
+        }
+        return events;
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    executeToolCall: async ({ toolCall, apiBaseUrl, authHeaders }) => {
+      const request = buildToolEndpointRequest(toolCall, apiBaseUrl);
+      if (!request) {
+        return { output: "No API endpoint defined for this tool", isError: true };
+      }
+      try {
+        const fetchOptions = {
+          method: request.method,
+          headers: {
+            "Content-Type": "application/json",
+            ...authHeaders
+          },
+          credentials: "include"
+        };
+        if ((request.method === "POST" || request.method === "PUT" || request.method === "PATCH") && Object.keys(request.bodyData).length > 0) {
+          fetchOptions.body = JSON.stringify(request.bodyData);
+        }
+        const response = await fetchFn(request.url, fetchOptions);
+        const text = await response.text();
+        let data;
+        try {
+          data = text ? JSON.parse(text) : null;
+        } catch {
+          data = { raw: text, status: response.status };
+        }
+        if (!response.ok) {
+          return { output: data, isError: true };
+        }
+        return { output: data };
+      } catch (error) {
+        return {
+          output: error instanceof Error ? error.message : "Network error",
+          isError: true
+        };
+      }
+    },
+    parseErrorResponse: async (response, fallback) => {
+      try {
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+          const errorData = await response.json();
+          if (typeof errorData?.error === "string") {
+            return errorData.error;
+          }
+          if (typeof errorData?.message === "string") {
+            return errorData.message;
+          }
+        }
+      } catch (error) {
+        console.warn("Failed to parse error response:", error);
+      }
+      return fallback;
+    }
+  };
+}
+
+// src/modules/agent/history/merge-history-threads.ts
+function mergeHistoryThreads(serverThreads, threadIndexByAgent) {
+  const entries = threadIndexByAgent.map((item) => [
+    item.threadId,
+    item
+  ]);
+  const threadIndexMap = new Map(entries);
+  return serverThreads.map((thread) => {
+    const indexItem = threadIndexMap.get(thread.id);
+    if (!indexItem) {
+      return thread;
+    }
+    return {
+      ...thread,
+      firstUserText: indexItem.firstUserText || thread.firstUserText
+    };
+  }).sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1);
+}
+
+// src/modules/agent/history/thread-index-storage.ts
+var THREAD_INDEX_STORAGE_KEY = "agent_thread_index_v1";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isStoredThreadIndexItem(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return typeof value.threadId === "string" && typeof value.agentId === "string" && typeof value.firstUserText === "string";
+}
+function readStorageRaw() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage.getItem(THREAD_INDEX_STORAGE_KEY);
+  } catch {
+    return null;
+  }
+}
+function writeStorageRaw(value) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    window.localStorage.setItem(THREAD_INDEX_STORAGE_KEY, value);
+  } catch {
+  }
+}
+function parseStorage() {
+  const raw = readStorageRaw();
+  if (!raw) {
+    return { items: [] };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isRecord2(parsed)) {
+      return { items: [] };
+    }
+    const itemValues = parsed.items;
+    if (!Array.isArray(itemValues)) {
+      return { items: [] };
+    }
+    const items = itemValues.filter(
+      (item) => isStoredThreadIndexItem(item)
+    );
+    return { items };
+  } catch {
+    return { items: [] };
+  }
+}
+function listThreadIndexByAgent(agentId) {
+  const storage = parseStorage();
+  return storage.items.filter((item) => item.agentId === agentId);
+}
+function upsertThreadIndexItem(item) {
+  const storage = parseStorage();
+  const existingIndex = storage.items.findIndex(
+    (stored) => stored.threadId === item.threadId && stored.agentId === item.agentId
+  );
+  if (existingIndex >= 0) {
+    const existingItem = storage.items[existingIndex];
+    if (!existingItem) {
+      storage.items.push(item);
+      writeStorageRaw(JSON.stringify(storage));
+      return;
+    }
+    storage.items[existingIndex] = {
+      threadId: existingItem.threadId,
+      agentId: existingItem.agentId,
+      firstUserText: item.firstUserText
+    };
+  } else {
+    storage.items.push(item);
+  }
+  writeStorageRaw(JSON.stringify(storage));
+}
+
+// src/modules/agent/error-utils.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function isErrorWithMessage(value) {
+  if (!isRecord3(value)) {
+    return false;
+  }
+  return typeof value.message === "string";
+}
+
+// src/modules/agent/domain/chat-state.ts
+function buildAssistantContent(text, toolCalls) {
+  const content = [];
+  if (text) {
+    content.push({ type: "text", text });
+  }
+  for (const toolCall of toolCalls) {
+    content.push({ type: "tool-call", toolCall });
+  }
+  return content;
+}
+function updateAssistantMessage(messages, assistantMessageId, update) {
+  const updated = [...messages];
+  const targetIndex = updated.findIndex((message) => message.id === assistantMessageId);
+  const existing = targetIndex >= 0 ? updated[targetIndex] : void 0;
+  if (!existing) {
+    return updated;
+  }
+  updated[targetIndex] = update(existing);
+  return updated;
+}
+function createUserMessage(id, text) {
+  return {
+    id,
+    role: "user",
+    content: [{ type: "text", text }]
+  };
+}
+function createAssistantStreamingMessage(id) {
+  return {
+    id,
+    role: "assistant",
+    content: [],
+    isStreaming: true
+  };
+}
+function createInitialChatState() {
+  return {
+    messages: [],
+    threadId: null,
+    isLoading: false,
+    error: null,
+    historyThreads: [],
+    isHistoryLoading: false,
+    historyError: null,
+    pendingToolCalls: /* @__PURE__ */ new Map()
+  };
+}
+function appendIntentText(current, intentMessage) {
+  if (!intentMessage.trim()) {
+    return current;
+  }
+  return current ? `${current}
+${intentMessage}` : intentMessage;
+}
+function selectPendingToolCalls(state) {
+  return Array.from(state.pendingToolCalls.values());
+}
+function chatStateReducer(state, action) {
+  switch (action.type) {
+    case "START_CHAT": {
+      return {
+        ...state,
+        messages: [
+          ...state.messages,
+          createUserMessage(action.payload.userMessageId, action.payload.text),
+          createAssistantStreamingMessage(action.payload.assistantMessageId)
+        ],
+        isLoading: true,
+        error: null
+      };
+    }
+    case "START_ASSISTANT_MESSAGE": {
+      return {
+        ...state,
+        messages: [...state.messages, createAssistantStreamingMessage(action.payload.assistantMessageId)]
+      };
+    }
+    case "UPDATE_ASSISTANT_PROGRESS": {
+      return {
+        ...state,
+        messages: updateAssistantMessage(
+          state.messages,
+          action.payload.assistantMessageId,
+          (message) => ({
+            id: message.id,
+            role: message.role,
+            content: buildAssistantContent(action.payload.text, action.payload.toolCalls),
+            isStreaming: true
+          })
+        )
+      };
+    }
+    case "FINISH_ASSISTANT_MESSAGE": {
+      return {
+        ...state,
+        messages: updateAssistantMessage(
+          state.messages,
+          action.payload.assistantMessageId,
+          (message) => ({
+            id: message.id,
+            role: message.role,
+            content: message.content,
+            isStreaming: false
+          })
+        )
+      };
+    }
+    case "UPSERT_TOOL_CALL_STATE": {
+      const nextPendingToolCalls = new Map(state.pendingToolCalls);
+      const current = nextPendingToolCalls.get(action.payload.toolCall.toolCallId);
+      if (current) {
+        nextPendingToolCalls.set(action.payload.toolCall.toolCallId, {
+          ...current,
+          status: action.payload.status,
+          result: action.payload.result,
+          error: action.payload.error
+        });
+      } else {
+        nextPendingToolCalls.set(action.payload.toolCall.toolCallId, {
+          toolCall: action.payload.toolCall,
+          status: action.payload.status,
+          result: action.payload.result,
+          error: action.payload.error
+        });
+      }
+      return {
+        ...state,
+        pendingToolCalls: nextPendingToolCalls
+      };
+    }
+    case "SET_LOADING": {
+      return {
+        ...state,
+        isLoading: action.payload.isLoading
+      };
+    }
+    case "SET_ERROR": {
+      return {
+        ...state,
+        error: action.payload.error
+      };
+    }
+    case "SET_THREAD_ID": {
+      return {
+        ...state,
+        threadId: action.payload.threadId
+      };
+    }
+    case "SET_HISTORY_THREADS": {
+      return {
+        ...state,
+        historyThreads: action.payload.threads
+      };
+    }
+    case "SET_HISTORY_LOADING": {
+      return {
+        ...state,
+        isHistoryLoading: action.payload.isHistoryLoading
+      };
+    }
+    case "SET_HISTORY_ERROR": {
+      return {
+        ...state,
+        historyError: action.payload.error
+      };
+    }
+    case "LOAD_HISTORY_THREAD": {
+      return {
+        ...state,
+        threadId: action.payload.threadId,
+        messages: action.payload.messages,
+        isLoading: false,
+        error: null,
+        pendingToolCalls: /* @__PURE__ */ new Map()
+      };
+    }
+    case "RESET_CHAT": {
+      return {
+        ...state,
+        messages: [],
+        threadId: null,
+        isLoading: false,
+        error: null,
+        pendingToolCalls: /* @__PURE__ */ new Map()
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+}
+
+// src/modules/agent/usecases/process-stream.ts
+function createProcessStreamProgress() {
+  return {
+    accumulatedText: "",
+    toolCalls: [],
+    serverResolvedToolCallIds: /* @__PURE__ */ new Set()
+  };
+}
+function normalizeErrorMessage(error) {
+  if (typeof error === "string" && error.trim().length > 0) {
+    return error;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  if (error !== void 0) {
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
+  return "Unknown error";
+}
+function processStreamEvents(input) {
+  const { events, assistantMessageId, dispatch, onError } = input;
+  let accumulatedText = input.progress?.accumulatedText ?? "";
+  const toolCalls = input.progress ? [...input.progress.toolCalls] : [];
+  const serverResolvedToolCallIds = input.progress ? new Set(input.progress.serverResolvedToolCallIds) : /* @__PURE__ */ new Set();
+  let resolvedAgentId;
+  for (const event of events) {
+    switch (event.type) {
+      case "thread-id": {
+        dispatch({ type: "SET_THREAD_ID", payload: { threadId: event.payload.threadId } });
+        break;
+      }
+      case "agent-id": {
+        resolvedAgentId = event.payload.agentId;
+        break;
+      }
+      case "text-delta": {
+        accumulatedText += event.payload.text;
+        dispatch({
+          type: "UPDATE_ASSISTANT_PROGRESS",
+          payload: { assistantMessageId, text: accumulatedText, toolCalls }
+        });
+        break;
+      }
+      case "tool-intent": {
+        accumulatedText = appendIntentText(accumulatedText, event.payload.message);
+        dispatch({
+          type: "UPDATE_ASSISTANT_PROGRESS",
+          payload: { assistantMessageId, text: accumulatedText, toolCalls }
+        });
+        break;
+      }
+      case "tool-call": {
+        toolCalls.push(event.payload);
+        dispatch({
+          type: "UPSERT_TOOL_CALL_STATE",
+          payload: {
+            toolCall: event.payload,
+            status: "pending"
+          }
+        });
+        dispatch({
+          type: "UPDATE_ASSISTANT_PROGRESS",
+          payload: { assistantMessageId, text: accumulatedText, toolCalls }
+        });
+        break;
+      }
+      case "tool-result": {
+        serverResolvedToolCallIds.add(event.payload.toolCallId);
+        const resolvedToolCall = toolCalls.find((toolCall) => toolCall.toolCallId === event.payload.toolCallId) ?? input.baseState.pendingToolCalls.get(event.payload.toolCallId)?.toolCall;
+        if (!resolvedToolCall) {
+          break;
+        }
+        dispatch({
+          type: "UPSERT_TOOL_CALL_STATE",
+          payload: {
+            toolCall: resolvedToolCall,
+            status: event.payload.isError ? "error" : "completed",
+            result: event.payload.result,
+            error: event.payload.isError ? normalizeErrorMessage(event.payload.result) : void 0
+          }
+        });
+        break;
+      }
+      case "finish": {
+        dispatch({ type: "FINISH_ASSISTANT_MESSAGE", payload: { assistantMessageId } });
+        break;
+      }
+      case "error": {
+        const errorMessage = normalizeErrorMessage(event.payload.error);
+        dispatch({ type: "SET_ERROR", payload: { error: errorMessage } });
+        onError?.(errorMessage);
+        break;
+      }
+    }
+  }
+  return {
+    clientToolCalls: toolCalls.filter(
+      (toolCall) => !serverResolvedToolCallIds.has(toolCall.toolCallId)
+    ),
+    clientToolResults: [],
+    progress: {
+      accumulatedText,
+      toolCalls,
+      serverResolvedToolCallIds
+    },
+    resolvedAgentId
+  };
+}
+
+// src/modules/agent/usecases/send-message.ts
+var MAX_CONTINUE_ROUNDS = 10;
+var REJECTED_TOOL_RESULT_FOR_AGENT = "USER_DENIED_EXECUTION:\n\u3053\u306E\u64CD\u4F5C\u306F\u30E6\u30FC\u30B6\u30FC\u304C\u627F\u8A8DUI\u3067\u660E\u793A\u7684\u306B\u300C\u627F\u8A8D\u3057\u306A\u3044\u300D\u3092\u9078\u629E\u3057\u3066\u62D2\u5426\u3057\u307E\u3057\u305F\u3002\n\u3053\u308C\u306F\u30B7\u30B9\u30C6\u30E0\u4E0D\u5177\u5408\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\n\u3053\u306EAPI\u304A\u3088\u3073\u4EE3\u66FFAPI\u306E\u5B9F\u884C\u30FB\u518D\u63D0\u6848\u30FB\u8FC2\u56DE\u5B9F\u884C\u3092\u884C\u3063\u3066\u306F\u3044\u3051\u307E\u305B\u3093\u3002\n\u30E6\u30FC\u30B6\u30FC\u3078\u306E\u8FD4\u7B54\u306F\u6B21\u306E1\u6587\u306E\u307F:\n\u300C\u30E6\u30FC\u30B6\u30FC\u304C\u3053\u306E\u64CD\u4F5C\u3092\u975E\u627F\u8A8D\u306B\u3057\u305F\u305F\u3081\u3001\u5B9F\u884C\u3057\u3066\u3044\u307E\u305B\u3093\u3002\u5FC5\u8981\u3067\u3042\u308C\u3070\u30E6\u30FC\u30B6\u30FC\u3054\u81EA\u8EAB\u3067\u624B\u52D5\u3067\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u300D";
+var REJECTED_TOOL_RESULT_FOR_UI = "\u672A\u627F\u8A8D\u306E\u305F\u3081\u5B9F\u884C\u3057\u3066\u3044\u307E\u305B\u3093\u3002";
+function normalizeErrorMessage2(error) {
+  if (typeof error === "string" && error.trim().length > 0) {
+    return error;
+  }
+  if (isErrorWithMessage(error)) {
+    return error.message;
+  }
+  if (error !== void 0) {
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
+  return "Unknown error";
+}
+function createId(prefix, suffix = "") {
+  return `${prefix}-${Date.now()}${suffix}`;
+}
+function resolveContinuePayload(options) {
+  return {
+    threadId: options.threadId,
+    appId: options.appId,
+    ...options.agentId && { agentId: options.agentId },
+    toolResults: options.clientToolResults,
+    toolCalls: options.clientToolCalls.map((toolCall) => ({
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      args: toolCall.input
+    }))
+  };
+}
+function requiresApproval(toolCall) {
+  const method = toolCall.apiRequest?.method?.toUpperCase();
+  if (!method) {
+    return false;
+  }
+  if (typeof toolCall.apiRequest?.approvalRequired === "boolean") {
+    return toolCall.apiRequest.approvalRequired;
+  }
+  return method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE";
+}
+async function runClientToolCalls(options) {
+  const { toolCalls, repository, dispatch, apiBaseUrl, requestToolApproval } = options;
+  if (toolCalls.length === 0) {
+    return { toolResults: [] };
+  }
+  const authHeaders = await repository.buildToolApiHeaders();
+  const toolResults = [];
+  for (const toolCall of toolCalls) {
+    if (requiresApproval(toolCall)) {
+      dispatch({
+        type: "UPSERT_TOOL_CALL_STATE",
+        payload: {
+          toolCall,
+          status: "awaiting-approval"
+        }
+      });
+      const approved = requestToolApproval ? await requestToolApproval(toolCall) : true;
+      if (!approved) {
+        dispatch({
+          type: "UPSERT_TOOL_CALL_STATE",
+          payload: {
+            toolCall,
+            status: "error",
+            result: REJECTED_TOOL_RESULT_FOR_UI,
+            error: REJECTED_TOOL_RESULT_FOR_UI
+          }
+        });
+        toolResults.push({
+          toolCallId: toolCall.toolCallId,
+          result: REJECTED_TOOL_RESULT_FOR_AGENT,
+          isError: true
+        });
+        continue;
+      }
+    }
+    dispatch({
+      type: "UPSERT_TOOL_CALL_STATE",
+      payload: {
+        toolCall,
+        status: "executing"
+      }
+    });
+    try {
+      const executionResult = await repository.executeToolCall({
+        toolCall,
+        apiBaseUrl,
+        authHeaders
+      });
+      const isError = executionResult.isError ?? false;
+      const error = isError ? normalizeErrorMessage2(executionResult.output) : void 0;
+      dispatch({
+        type: "UPSERT_TOOL_CALL_STATE",
+        payload: {
+          toolCall,
+          status: isError ? "error" : "completed",
+          result: executionResult.output,
+          error
+        }
+      });
+      toolResults.push({
+        toolCallId: toolCall.toolCallId,
+        result: executionResult.output,
+        isError
+      });
+    } catch (error) {
+      const errorMessage = normalizeErrorMessage2(error);
+      dispatch({
+        type: "UPSERT_TOOL_CALL_STATE",
+        payload: {
+          toolCall,
+          status: "error",
+          error: errorMessage
+        }
+      });
+      toolResults.push({
+        toolCallId: toolCall.toolCallId,
+        result: errorMessage,
+        isError: true
+      });
+    }
+  }
+  return { toolResults };
+}
+async function collectAndProcessStream(options) {
+  let progress = createProcessStreamProgress();
+  const initialToolCalls = [];
+  let latestResult = {
+    clientToolCalls: initialToolCalls};
+  let resolvedAgentId;
+  let processedBatchCount = 0;
+  const processEvents = (events) => {
+    if (events.length === 0) {
+      return;
+    }
+    processedBatchCount += 1;
+    const result = processStreamEvents({
+      events,
+      assistantMessageId: options.assistantMessageId,
+      baseState: options.getState(),
+      dispatch: options.dispatch,
+      onError: options.onError,
+      progress
+    });
+    progress = result.progress;
+    latestResult = result;
+    if (result.resolvedAgentId) {
+      resolvedAgentId = result.resolvedAgentId;
+    }
+    for (const event of events) {
+      if (event.type === "thread-id") {
+        options.onThreadId(event.payload.threadId);
+      }
+    }
+  };
+  const allEvents = await options.repository.collectStreamEvents(options.response, {
+    onEvents: processEvents
+  });
+  if (allEvents.length > 0 && processedBatchCount === 0) {
+    processEvents(allEvents);
+  }
+  return {
+    clientToolCalls: latestResult.clientToolCalls,
+    resolvedAgentId
+  };
+}
+async function sendMessageUseCase(input) {
+  const state = input.getState();
+  const trimmedMessage = input.message.trim();
+  if (!trimmedMessage || state.isLoading) {
+    return;
+  }
+  const userMessageId = createId("user");
+  const assistantMessageId = createId("assistant");
+  const agentId = input.config.agentId;
+  const appId = input.config.appId;
+  let activeThreadId = state.threadId;
+  const handleError = (error) => {
+    const errorMessage = normalizeErrorMessage2(error);
+    input.dispatch({ type: "SET_ERROR", payload: { error: errorMessage } });
+    input.onError?.(errorMessage);
+  };
+  input.dispatch({
+    type: "START_CHAT",
+    payload: {
+      userMessageId,
+      text: trimmedMessage,
+      assistantMessageId
+    }
+  });
+  try {
+    const headers = await input.repository.buildAgentHeaders(input.config.getAgentHeaders);
+    const response = await input.repository.sendChat({
+      agentServerUrl: input.config.agentServerUrl,
+      threadId: state.threadId,
+      message: trimmedMessage,
+      appId,
+      agentId,
+      headers,
+      signal: input.signal
+    });
+    if (!response.ok) {
+      const errorMessage = await input.repository.parseErrorResponse(
+        response,
+        "Failed to send message"
+      );
+      throw new Error(errorMessage);
+    }
+    const firstResult = await collectAndProcessStream({
+      response,
+      repository: input.repository,
+      assistantMessageId,
+      getState: input.getState,
+      dispatch: input.dispatch,
+      onError: input.onError,
+      onThreadId: (threadId) => {
+        activeThreadId = threadId;
+        input.onThreadResolved?.({
+          threadId,
+          agentId: agentId || input.config.appId,
+          firstUserText: trimmedMessage
+        });
+      }
+    });
+    const pinnedAgentId = firstResult.resolvedAgentId || agentId;
+    let currentToolCalls = firstResult.clientToolCalls;
+    let { toolResults } = await runClientToolCalls({
+      toolCalls: currentToolCalls,
+      repository: input.repository,
+      dispatch: input.dispatch,
+      apiBaseUrl: input.config.apiBaseUrl,
+      requestToolApproval: input.requestToolApproval
+    });
+    let continueRound = 0;
+    let shouldContinue = toolResults.length > 0;
+    while (shouldContinue) {
+      continueRound += 1;
+      if (continueRound > MAX_CONTINUE_ROUNDS) {
+        handleError(`Tool execution loop exceeded maximum rounds (${MAX_CONTINUE_ROUNDS}).`);
+        break;
+      }
+      const continueMessageId = createId("assistant", `-${continueRound}`);
+      input.dispatch({
+        type: "START_ASSISTANT_MESSAGE",
+        payload: { assistantMessageId: continueMessageId }
+      });
+      const continueHeaders = await input.repository.buildAgentHeaders(
+        input.config.getAgentHeaders
+      );
+      const continuePayload = resolveContinuePayload({
+        threadId: activeThreadId,
+        appId,
+        agentId: pinnedAgentId,
+        clientToolResults: toolResults,
+        clientToolCalls: currentToolCalls
+      });
+      const continueResponse = await input.repository.continueChat({
+        agentServerUrl: input.config.agentServerUrl,
+        payload: continuePayload,
+        headers: continueHeaders,
+        signal: input.signal
+      });
+      if (!continueResponse.ok) {
+        const continueErrorText = await continueResponse.text().catch(() => continueResponse.statusText);
+        throw new Error(`Failed to continue agent after tool execution: ${continueErrorText}`);
+      }
+      const continueResult = await collectAndProcessStream({
+        response: continueResponse,
+        repository: input.repository,
+        assistantMessageId: continueMessageId,
+        getState: input.getState,
+        dispatch: input.dispatch,
+        onError: input.onError,
+        onThreadId: (threadId) => {
+          activeThreadId = threadId;
+          input.onThreadResolved?.({
+            threadId,
+            agentId: agentId || input.config.appId,
+            firstUserText: trimmedMessage
+          });
+        }
+      });
+      const toolExecution = await runClientToolCalls({
+        toolCalls: continueResult.clientToolCalls,
+        repository: input.repository,
+        dispatch: input.dispatch,
+        apiBaseUrl: input.config.apiBaseUrl,
+        requestToolApproval: input.requestToolApproval
+      });
+      currentToolCalls = continueResult.clientToolCalls;
+      toolResults = toolExecution.toolResults;
+      shouldContinue = toolResults.length > 0;
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    handleError(error);
+  } finally {
+    input.dispatch({ type: "SET_LOADING", payload: { isLoading: false } });
+  }
+}
+
+// src/modules/agent/use-agent-chat.ts
+function normalizeErrorMessage3(error) {
+  if (typeof error === "string" && error.trim().length > 0) {
+    return error;
+  }
+  if (isErrorWithMessage(error)) {
+    return error.message;
+  }
+  return "Unknown error";
+}
+function resolveFirstUserText(messages) {
+  const firstUserMessage = messages.find((message) => message.role === "user");
+  if (!firstUserMessage) {
+    return "";
+  }
+  for (const part of firstUserMessage.content) {
+    if (part.type === "text") {
+      return part.text;
+    }
+  }
+  return "";
+}
+function useAgentChat(options) {
+  const { config } = options;
+  const {
+    agentServerUrl,
+    appId,
+    apiBaseUrl,
+    agentId,
+    onError,
+    getAuthToken,
+    getAgentHeaders,
+    disableToolApiAuthHeader
+  } = config;
+  const resolvedAgentId = agentId;
+  const resolvedGetAgentHeaders = useCallback(async () => {
+    return getAgentHeaders ? getAgentHeaders() : {};
+  }, [getAgentHeaders]);
+  const [state, dispatch] = useReducer(chatStateReducer, void 0, createInitialChatState);
+  const [activeApprovalRequest, setActiveApprovalRequest] = useState(null);
+  const abortControllerRef = useRef(null);
+  const approvalResolverRef = useRef(null);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const settleApproval = useCallback((approved) => {
+    const resolver = approvalResolverRef.current;
+    if (!resolver) {
+      return;
+    }
+    approvalResolverRef.current = null;
+    setActiveApprovalRequest(null);
+    resolver(approved);
+  }, []);
+  const requestToolApproval = useCallback(
+    (toolCall) => {
+      if (approvalResolverRef.current) {
+        settleApproval(false);
+      }
+      const actionLabel = toolCall.apiRequest?.actionLabel?.trim() || `${toolCall.apiRequest?.method ?? ""} ${toolCall.apiRequest?.path ?? ""}`.trim() || toolCall.toolName;
+      const riskLevel = toolCall.apiRequest?.riskLevel ?? "write";
+      setActiveApprovalRequest({
+        toolCall,
+        actionLabel,
+        riskLevel
+      });
+      return new Promise((resolve) => {
+        approvalResolverRef.current = resolve;
+      });
+    },
+    [settleApproval]
+  );
+  const approveToolCall = useCallback(() => {
+    settleApproval(true);
+  }, [settleApproval]);
+  const rejectToolCall = useCallback(() => {
+    settleApproval(false);
+  }, [settleApproval]);
+  const repository = useMemo(
+    () => createAgentRepository({
+      getAuthToken,
+      disableToolApiAuthHeader
+    }),
+    [getAuthToken, disableToolApiAuthHeader]
+  );
+  const loadHistoryThreads = useCallback(async () => {
+    dispatch({ type: "SET_HISTORY_LOADING", payload: { isHistoryLoading: true } });
+    dispatch({ type: "SET_HISTORY_ERROR", payload: { error: null } });
+    try {
+      const headers = await repository.buildAgentHeaders(resolvedGetAgentHeaders);
+      const response = await repository.listThreads({
+        agentServerUrl,
+        headers,
+        agentId: resolvedAgentId,
+        appId
+      });
+      if (!response.ok) {
+        const errorMessage = await repository.parseErrorResponse(
+          response,
+          "Failed to fetch history threads"
+        );
+        throw new Error(errorMessage);
+      }
+      const body = await response.json();
+      const historyResult = normalizeListThreadsResponse(body);
+      const threadIndexByAgent = listThreadIndexByAgent(resolvedAgentId || appId);
+      const mergedThreads = mergeHistoryThreads(historyResult.threads, threadIndexByAgent);
+      dispatch({ type: "SET_HISTORY_THREADS", payload: { threads: mergedThreads } });
+    } catch (error) {
+      const errorMessage = normalizeErrorMessage3(error);
+      dispatch({ type: "SET_HISTORY_ERROR", payload: { error: errorMessage } });
+      onError?.(errorMessage);
+    } finally {
+      dispatch({ type: "SET_HISTORY_LOADING", payload: { isHistoryLoading: false } });
+    }
+  }, [agentServerUrl, appId, onError, repository, resolvedAgentId, resolvedGetAgentHeaders]);
+  const loadThreadMessages = useCallback(
+    async (threadId) => {
+      dispatch({ type: "SET_HISTORY_LOADING", payload: { isHistoryLoading: true } });
+      dispatch({ type: "SET_HISTORY_ERROR", payload: { error: null } });
+      try {
+        const headers = await repository.buildAgentHeaders(resolvedGetAgentHeaders);
+        const response = await repository.getThreadMessages({
+          agentServerUrl,
+          headers,
+          threadId,
+          agentId: resolvedAgentId,
+          appId
+        });
+        if (!response.ok) {
+          const errorMessage = await repository.parseErrorResponse(
+            response,
+            "Failed to fetch thread messages"
+          );
+          throw new Error(errorMessage);
+        }
+        const body = await response.json();
+        const historyResult = normalizeGetThreadMessagesResponse(body);
+        const resolvedThreadId = historyResult.threadId || threadId;
+        dispatch({
+          type: "LOAD_HISTORY_THREAD",
+          payload: {
+            threadId: resolvedThreadId,
+            messages: historyResult.messages
+          }
+        });
+        const firstUserText = resolveFirstUserText(historyResult.messages);
+        if (firstUserText) {
+          upsertThreadIndexItem({
+            threadId: resolvedThreadId,
+            agentId: resolvedAgentId || appId,
+            firstUserText
+          });
+        }
+      } catch (error) {
+        const errorMessage = normalizeErrorMessage3(error);
+        dispatch({ type: "SET_HISTORY_ERROR", payload: { error: errorMessage } });
+        dispatch({ type: "SET_ERROR", payload: { error: errorMessage } });
+        onError?.(errorMessage);
+      } finally {
+        dispatch({ type: "SET_HISTORY_LOADING", payload: { isHistoryLoading: false } });
+      }
+    },
+    [agentServerUrl, appId, onError, repository, resolvedAgentId, resolvedGetAgentHeaders]
+  );
+  const sendMessage = useCallback(
+    async (message) => {
+      abortControllerRef.current = new AbortController();
+      try {
+        await sendMessageUseCase({
+          message,
+          repository,
+          dispatch,
+          getState: () => stateRef.current,
+          config: {
+            agentServerUrl,
+            appId,
+            apiBaseUrl,
+            agentId: resolvedAgentId,
+            getAgentHeaders: resolvedGetAgentHeaders,
+            disableToolApiAuthHeader
+          },
+          onError,
+          signal: abortControllerRef.current.signal,
+          requestToolApproval,
+          onThreadResolved: (payload) => {
+            upsertThreadIndexItem({
+              threadId: payload.threadId,
+              agentId: payload.agentId || appId,
+              firstUserText: payload.firstUserText
+            });
+          }
+        });
+      } finally {
+        abortControllerRef.current = null;
+      }
+    },
+    [
+      repository,
+      agentServerUrl,
+      appId,
+      apiBaseUrl,
+      resolvedAgentId,
+      resolvedGetAgentHeaders,
+      disableToolApiAuthHeader,
+      onError,
+      requestToolApproval
+    ]
+  );
+  const clearChat = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    settleApproval(false);
+    dispatch({ type: "RESET_CHAT" });
+  }, [settleApproval]);
+  const pendingToolCalls = useMemo(() => selectPendingToolCalls(state), [state.pendingToolCalls, state]);
+  return {
+    messages: state.messages,
+    threadId: state.threadId,
+    isLoading: state.isLoading,
+    error: state.error,
+    historyThreads: state.historyThreads,
+    isHistoryLoading: state.isHistoryLoading,
+    historyError: state.historyError,
+    pendingToolCalls,
+    activeApprovalRequest,
+    approveToolCall,
+    rejectToolCall,
+    sendMessage,
+    loadHistoryThreads,
+    loadThreadMessages,
+    clearChat,
+    config
+  };
+}
+
+// src/components/agent/provider/runtime-config.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function normalizeUrl(url) {
+  return url.replace(/\/$/, "");
+}
+var AGENT_SERVER_URL_PROD = "https://agent-server-prod--agent-platform-dev-8e3ae.asia-east1.hosted.app/api/agent";
+var AGENT_SERVER_URL_DEV = "http://localhost:3002/api/agent";
+function resolveAgentServerUrl() {
+  return process.env.NODE_ENV === "production" ? AGENT_SERVER_URL_PROD : AGENT_SERVER_URL_DEV;
+}
+function resolveAgentRuntimeConfig(config, getAuthToken) {
+  const missingRequiredKeys = [];
+  if (!isNonEmptyString(config.apiBaseUrl)) {
+    missingRequiredKeys.push("apiBaseUrl");
+  }
+  if (!isNonEmptyString(config.appId)) {
+    missingRequiredKeys.push("appId");
+  }
+  if (missingRequiredKeys.length > 0) {
+    throw new Error(`[AgentProvider] Missing required config: ${missingRequiredKeys.join(", ")}`);
+  }
+  const apiBaseUrl = normalizeUrl(config.apiBaseUrl);
+  const agentServerUrl = resolveAgentServerUrl();
+  return {
+    ...config,
+    apiBaseUrl,
+    agentServerUrl,
+    getAuthToken
+  };
+}
+function AgentProvider({ children, ...config }) {
+  const resolvedServerUrl = resolveAgentServerUrl();
+  const auth = useAgentAuth(resolvedServerUrl);
+  const lastNotifiedErrorRef = useRef(null);
+  useEffect(() => {
+    if (auth.error && auth.error !== lastNotifiedErrorRef.current) {
+      lastNotifiedErrorRef.current = auth.error;
+      config.onError?.(`[AgentAuth] ${auth.error}`);
+    }
+  }, [auth.error, config.onError]);
+  if (!auth.isReady && !auth.error) {
+    return /* @__PURE__ */ jsx("div", { "aria-busy": "true" });
+  }
+  if (auth.error) {
+    return /* @__PURE__ */ jsx("div", { role: "alert", children: /* @__PURE__ */ jsx("p", { children: "\u8A8D\u8A3C\u306E\u521D\u671F\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u30DA\u30FC\u30B8\u3092\u518D\u8AAD\u307F\u8FBC\u307F\u3057\u3066\u304F\u3060\u3055\u3044\u3002" }) });
+  }
+  return /* @__PURE__ */ jsx(AgentProviderInner, { config, getAuthToken: auth.getToken, children });
+}
+function AgentProviderInner({
+  children,
+  config,
+  getAuthToken
+}) {
+  const runtimeConfig = resolveAgentRuntimeConfig(config, getAuthToken);
+  const value = useAgentChat({ config: runtimeConfig });
+  return /* @__PURE__ */ jsx(AgentContext.Provider, { value, children });
+}
+function AgentScreen({
+  appId,
+  agentId,
+  onError,
+  apiBaseUrl,
+  getAgentHeaders,
+  disableToolApiAuthHeader,
+  toolApprovalLabels,
+  className
+}) {
+  return /* @__PURE__ */ jsx(
+    AgentProvider,
+    {
+      appId,
+      agentId,
+      onError,
+      apiBaseUrl,
+      getAgentHeaders,
+      disableToolApiAuthHeader,
+      toolApprovalLabels,
+      children: /* @__PURE__ */ jsx(AgentContainer, { className })
+    }
+  );
+}
+
+export { AgentScreen };