@tutti-os/agent-gui 0.0.4 → 0.0.6

package/dist/chunk-FKCXHCPO.js

@@ -0,0 +1,3478 @@
+import {
+  translate,
+  useTranslation
+} from "./chunk-JWVLIF5R.js";
+import {
+  resolveAgentWorkspaceFileVisualKind
+} from "./chunk-PJP5BUU6.js";
+import {
+  claudeRoundedUrl,
+  codexRoundedUrl,
+  geminiRoundedUrl,
+  hermesRoundedUrl,
+  manageAgentClaudeCodeUrl,
+  manageAgentCodexUrl,
+  manageAgentGeminiUrl,
+  manageAgentHermesUrl,
+  manageAgentNextopUrl,
+  manageAgentOpenclawUrl,
+  nextopDocRoundedUrl,
+  openclawRoundedUrl
+} from "./chunk-ZU3FKYMG.js";
+
+// agentActivityRuntime.tsx
+import {
+  createContext,
+  useContext,
+  useSyncExternalStore
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var AgentActivityRuntimeContext = createContext(
+  null
+);
+var currentAgentActivityRuntime = null;
+function AgentActivityRuntimeProvider({
+  children,
+  runtime
+}) {
+  currentAgentActivityRuntime = runtime ?? null;
+  return /* @__PURE__ */ jsx(AgentActivityRuntimeContext.Provider, { value: runtime ?? null, children });
+}
+function useAgentActivityRuntime() {
+  const runtime = useContext(AgentActivityRuntimeContext) ?? getTestAgentActivityRuntime();
+  if (!runtime) {
+    throw new Error(
+      "AgentActivityRuntimeProvider is missing an AgentActivityRuntime instance."
+    );
+  }
+  return runtime;
+}
+function useOptionalAgentActivityRuntime() {
+  return useContext(AgentActivityRuntimeContext) ?? getTestAgentActivityRuntime();
+}
+function useAgentActivitySnapshot(workspaceId) {
+  const runtime = useAgentActivityRuntime();
+  const normalizedWorkspaceId = workspaceId.trim();
+  return useSyncExternalStore(
+    (listener) => runtime.subscribe(normalizedWorkspaceId, listener),
+    () => runtime.getSnapshot(normalizedWorkspaceId),
+    () => runtime.getSnapshot(normalizedWorkspaceId)
+  );
+}
+function getAgentActivityRuntime() {
+  const runtime = getExplicitWindowTestAgentActivityRuntime() ?? currentAgentActivityRuntime ?? getTestAgentActivityRuntime();
+  if (!runtime) {
+    throw new Error(
+      "AgentActivityRuntimeProvider is missing an AgentActivityRuntime instance."
+    );
+  }
+  return runtime;
+}
+function getOptionalAgentActivityRuntime() {
+  return getExplicitWindowTestAgentActivityRuntime() ?? currentAgentActivityRuntime ?? getTestAgentActivityRuntime();
+}
+function resetAgentActivityRuntimeForTests() {
+  if (process.env.NODE_ENV === "test") {
+    currentAgentActivityRuntime = null;
+  }
+}
+function setAgentActivityRuntimeForTests(runtime) {
+  if (process.env.NODE_ENV === "test") {
+    currentAgentActivityRuntime = runtime;
+  }
+}
+function getTestAgentActivityRuntime() {
+  if (process.env.NODE_ENV !== "test") {
+    return null;
+  }
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const explicitRuntime = getExplicitWindowTestAgentActivityRuntime();
+  if (explicitRuntime) {
+    return explicitRuntime;
+  }
+  if (currentAgentActivityRuntime) {
+    return currentAgentActivityRuntime;
+  }
+  const testRuntime = window.agentActivityRuntime;
+  return testRuntime ?? null;
+}
+function getExplicitWindowTestAgentActivityRuntime() {
+  if (process.env.NODE_ENV !== "test" || typeof window === "undefined") {
+    return null;
+  }
+  const testDescriptor = Object.getOwnPropertyDescriptor(
+    window,
+    "agentActivityRuntime"
+  );
+  if (!testDescriptor || !("value" in testDescriptor)) {
+    return null;
+  }
+  return testDescriptor.value ?? null;
+}
+
+// agentActivityHost.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useMemo
+} from "react";
+
+// host/agentHostApi.ts
+function toAgentHostRuntimeApi(hostApi) {
+  return {
+    account: hostApi.account,
+    agentGuiBatch: hostApi.agentGuiBatch ?? {},
+    clipboard: hostApi.clipboard,
+    debug: hostApi.debug,
+    filesystem: hostApi.filesystem,
+    meta: hostApi.meta,
+    onHostEvent: hostApi.onHostEvent,
+    runtime: hostApi.runtime,
+    userProjects: hostApi.userProjects,
+    workspace: hostApi.workspace,
+    workspaceAgentProbes: hostApi.workspaceAgentProbes
+  };
+}
+
+// agentActivityHost.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var AgentActivityHostContext = createContext2(
+  null
+);
+var currentAgentHostApi = null;
+function AgentActivityHostProvider({
+  agentActivityRuntime,
+  agentHostApi,
+  children
+}) {
+  const resolvedAgentHostApi = useMemo(
+    () => agentHostApi ? toAgentHostRuntimeApi(agentHostApi) : null,
+    [agentHostApi]
+  );
+  currentAgentHostApi = resolvedAgentHostApi;
+  return /* @__PURE__ */ jsx2(AgentActivityRuntimeProvider, { runtime: agentActivityRuntime, children: /* @__PURE__ */ jsx2(AgentActivityHostContext.Provider, { value: resolvedAgentHostApi, children }) });
+}
+function useAgentHostApi() {
+  const agentHostApi = useContext2(AgentActivityHostContext) ?? getTestAgentHostApi();
+  if (!agentHostApi) {
+    throw new Error(
+      "AgentActivityHostProvider is missing an agentHostApi instance."
+    );
+  }
+  return agentHostApi;
+}
+function useOptionalAgentHostApi() {
+  return useContext2(AgentActivityHostContext) ?? getTestAgentHostApi();
+}
+function getOptionalAgentHostApi() {
+  return getExplicitWindowTestAgentHostApi() ?? currentAgentHostApi ?? getTestAgentHostApi();
+}
+function getTestAgentHostApi() {
+  if (process.env.NODE_ENV !== "test") {
+    return null;
+  }
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const explicitAgentHostApi = getExplicitWindowTestAgentHostApi();
+  if (explicitAgentHostApi) {
+    return explicitAgentHostApi;
+  }
+  if (currentAgentHostApi) {
+    return currentAgentHostApi;
+  }
+  const testAgentHostApi = window.agentHostApi;
+  return testAgentHostApi ? toAgentHostRuntimeApi(testAgentHostApi) : null;
+}
+function getExplicitWindowTestAgentHostApi() {
+  if (process.env.NODE_ENV !== "test" || typeof window === "undefined") {
+    return null;
+  }
+  const testDescriptor = Object.getOwnPropertyDescriptor(
+    window,
+    "agentHostApi"
+  );
+  if (!testDescriptor || !("value" in testDescriptor)) {
+    return null;
+  }
+  const testAgentHostApi = testDescriptor.value;
+  return testAgentHostApi ? toAgentHostRuntimeApi(testAgentHostApi) : null;
+}
+
+// shared/managedAgentProviders.ts
+function normalizeManagedAgentProvider(provider) {
+  const normalized = provider?.trim().toLowerCase().replace(/[_\s]+/gu, "-") ?? "";
+  switch (normalized) {
+    case "claude":
+    case "claude-code":
+      return "claude-code";
+    case "nexight":
+    case "nextop-doc":
+      return "nextop";
+    default:
+      return normalized;
+  }
+}
+
+// shared/managedAgentIcons.ts
+var MANAGED_AGENT_ICON_URLS = {
+  "claude-code": manageAgentClaudeCodeUrl,
+  codex: manageAgentCodexUrl,
+  gemini: manageAgentGeminiUrl,
+  hermes: manageAgentHermesUrl,
+  nextop: manageAgentNextopUrl,
+  openclaw: manageAgentOpenclawUrl
+};
+var MANAGED_AGENT_ICON_ROUNDED_URLS = {
+  "claude-code": claudeRoundedUrl,
+  codex: codexRoundedUrl,
+  gemini: geminiRoundedUrl,
+  hermes: hermesRoundedUrl,
+  nextop: nextopDocRoundedUrl,
+  openclaw: openclawRoundedUrl
+};
+var MANAGED_AGENT_ROUNDED_ICON_FALLBACK_URL = nextopDocRoundedUrl;
+var MANAGED_AGENT_ICON_FALLBACK_URL = manageAgentNextopUrl;
+function managedAgentRoundedIconUrl(provider) {
+  return MANAGED_AGENT_ICON_ROUNDED_URLS[normalizeManagedAgentProvider(provider)] ?? MANAGED_AGENT_ROUNDED_ICON_FALLBACK_URL;
+}
+
+// shared/agentConversation/approvalOptionPresentation.ts
+function approvalOptionDisplayLabel(option, intent = {}) {
+  const idToken = normalizeApprovalOptionToken(option.id);
+  const kindToken = normalizeApprovalOptionToken(option.kind);
+  const label = option.label.trim();
+  const specificTranslationKey = approvalOptionSpecificTranslationKey(
+    idToken,
+    label,
+    intent
+  );
+  if (specificTranslationKey) {
+    return translate(specificTranslationKey);
+  }
+  const providerLabelTranslation = approvalOptionProviderLabelTranslation(label);
+  if (providerLabelTranslation) {
+    return translate(
+      providerLabelTranslation.key,
+      providerLabelTranslation.params
+    );
+  }
+  if ((idToken === "allowonce" || kindToken === "allowonce") && isGenericAllowOnceLabel(label)) {
+    return translate("agentHost.agentGui.approvalOptions.allowOnce");
+  }
+  if ((idToken === "allowalways" || idToken === "allowall" || kindToken === "allowalways") && isGenericApprovalLabel(label)) {
+    return translate("agentHost.agentGui.approvalOptions.allowAlways");
+  }
+  if (idToken === "rejectalways" || kindToken === "rejectalways") {
+    return translate("agentHost.agentGui.approvalOptions.rejectAlways");
+  }
+  if (idToken === "rejectonce" || idToken === "reject" || idToken === "deny" || kindToken === "rejectonce" || kindToken === "reject" || kindToken === "deny") {
+    return intent.feedback ? translate("agentHost.agentGui.approvalOptions.rejectWithFollowUp") : translate("agentHost.agentGui.approvalOptions.rejectOnce");
+  }
+  return label || option.id;
+}
+function approvalOptionVisualPresentation(option, intent = {}) {
+  const commandPrefix = approvalOptionCommandPrefix(option.label);
+  if (commandPrefix) {
+    return {
+      label: translate(
+        "agentHost.agentGui.approvalOptions.allowAlwaysForCommandPrefixLead"
+      ),
+      commandPrefix
+    };
+  }
+  return {
+    label: approvalOptionDisplayLabel(option, intent)
+  };
+}
+function normalizeApprovalOptionToken(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function approvalOptionSpecificTranslationKey(token, label, intent = {}) {
+  const labelToken = normalizeApprovalOptionToken(label);
+  switch (token) {
+    case "approved":
+      return isGenericAllowOnceLabel(label) ? "agentHost.agentGui.approvalOptions.allowOnce" : null;
+    case "approvedforsession":
+      return labelToken === "allowforthissession" ? "agentHost.agentGui.approvalOptions.allowForSession" : null;
+    case "approvedalways":
+      return isGenericApprovalLabel(label) ? "agentHost.agentGui.approvalOptions.allowAlways" : null;
+    case "bypasspermissions":
+      return "agentHost.agentGui.approvalOptions.bypassPermissions";
+    case "auto":
+      return labelToken === "yesanduseautomode" ? "agentHost.agentGui.approvalOptions.autoMode" : null;
+    case "acceptedits":
+      return "agentHost.agentGui.approvalOptions.acceptEdits";
+    case "default":
+      return labelToken === "yesandmanuallyapproveedits" ? "agentHost.agentGui.approvalOptions.manualApproval" : null;
+    case "cancel":
+      return !intent.feedback && labelToken === "cancel" ? "common.cancel" : null;
+    default:
+      return null;
+  }
+}
+function approvalOptionProviderLabelTranslation(label) {
+  const commandPrefix = approvalOptionCommandPrefix(label);
+  if (commandPrefix) {
+    return {
+      key: "agentHost.agentGui.approvalOptions.allowAlwaysForCommandPrefix",
+      params: { command: commandPrefix }
+    };
+  }
+  const allowScopeMatch = label.match(/^Yes,\s*and don't ask again for (.+)$/i);
+  if (allowScopeMatch?.[1]) {
+    return {
+      key: "agentHost.agentGui.approvalOptions.allowAlwaysForScope",
+      params: { scope: allowScopeMatch[1] }
+    };
+  }
+  const alwaysAllowMatch = label.match(/^Always Allow\s+(.+)$/i);
+  if (alwaysAllowMatch?.[1]) {
+    return {
+      key: "agentHost.agentGui.approvalOptions.alwaysAllowScope",
+      params: { scope: alwaysAllowMatch[1] }
+    };
+  }
+  return null;
+}
+function approvalOptionCommandPrefix(label) {
+  const commandPrefixMatch = label.match(
+    /^Yes,\s*and don't ask again for commands that start with `([^`]+)`$/i
+  );
+  return commandPrefixMatch?.[1]?.trim() || null;
+}
+function isGenericApprovalLabel(label) {
+  const token = normalizeApprovalOptionToken(label);
+  return token === "" || token === "allowalways" || token === "allowall" || token === "alwaysallow" || token === "allowanddontaskagain" || token === "yesanddontaskagain";
+}
+function isGenericAllowOnceLabel(label) {
+  const token = normalizeApprovalOptionToken(label);
+  return token === "" || token === "allow" || token === "allowonce" || token === "yes" || token === "yesproceed" || token === "yesandproceed";
+}
+
+// shared/agentConversation/promptToolDetails.ts
+function getPromptToolDetails(input) {
+  if (!input) {
+    return [];
+  }
+  const detailInput = resolveToolDetailInput(input);
+  const command = commandStringValue(detailInput.command) ?? commandStringValue(detailInput.cmd);
+  if (command) {
+    return [
+      {
+        kind: "command",
+        value: command,
+        ...stringValue(detailInput.description) ? { meta: stringValue(detailInput.description) } : {}
+      }
+    ];
+  }
+  const filePath = stringValue(detailInput.file_path) ?? stringValue(detailInput.filePath) ?? stringValue(detailInput.path) ?? stringValue(detailInput.notebook_path);
+  if (filePath) {
+    const lineRange = formatLineRange(detailInput);
+    return [
+      {
+        kind: "path",
+        value: filePath,
+        ...lineRange ? { meta: lineRange } : {}
+      }
+    ];
+  }
+  const query = stringValue(detailInput.query) ?? stringValue(detailInput.search_query) ?? stringValue(detailInput.searchQuery) ?? stringValue(detailInput.pattern);
+  if (query) {
+    return [
+      {
+        kind: "query",
+        value: query
+      }
+    ];
+  }
+  return [];
+}
+function isPromptRequestIdTitle(value) {
+  return /^request(?:id|ID)\s*:/u.test(value.trim());
+}
+function resolveToolDetailInput(input) {
+  const toolCall = objectValue(input.toolCall);
+  return firstObjectValue(input, [
+    "command",
+    "cmd",
+    "file_path",
+    "filePath",
+    "path",
+    "notebook_path",
+    "query",
+    "search_query",
+    "searchQuery",
+    "pattern"
+  ]) ?? firstObjectValue(toolCall, [
+    "input",
+    "rawInput",
+    "raw_input",
+    "arguments",
+    "args"
+  ]) ?? toolCall ?? input;
+}
+function firstObjectValue(input, keys) {
+  if (!input) {
+    return null;
+  }
+  if (keys.some((key) => stringValue(input[key]))) {
+    return input;
+  }
+  for (const key of keys) {
+    const value = objectValue(input[key]);
+    if (value) {
+      return value;
+    }
+  }
+  return null;
+}
+function formatLineRange(input) {
+  const start = numericValue(input.startLine) ?? numericValue(input.start_line);
+  const end = numericValue(input.endLine) ?? numericValue(input.end_line);
+  if (start === null || end === null) {
+    return null;
+  }
+  return start === end ? `L${start}` : `L${start}-${end}`;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function commandStringValue(value) {
+  if (typeof value === "string") {
+    return stringValue(value);
+  }
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const shellFlag = stringValue(value[value.length - 2]);
+  const shellCommand = stringValue(value[value.length - 1]);
+  if ((shellFlag === "-c" || shellFlag === "-lc") && shellCommand) {
+    return shellCommand;
+  }
+  const parts = value.flatMap((part) => {
+    const text = stringValue(part);
+    return text ? [text] : [];
+  });
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+// shared/agentConversation/components/AgentInteractivePromptSurface.tsx
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState
+} from "react";
+
+// app/renderer/components/icons/MessageSquareMoreIcon.tsx
+import {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useRef
+} from "react";
+import {
+  motion,
+  useAnimation,
+  useReducedMotion
+} from "framer-motion";
+
+// app/renderer/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// app/renderer/components/icons/MessageSquareMoreIcon.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var DOT_TRANSITION = {
+  times: [0, 0.1, 0.1, 0.2, 0.5, 0.6, 0.6, 0.7],
+  duration: 1.5
+};
+var DOT_VARIANTS = {
+  normal: {
+    opacity: 1
+  },
+  animate: (custom) => ({
+    opacity: [1, 0, 0, 1, 1, 0, 0, 1],
+    transition: {
+      opacity: {
+        ...DOT_TRANSITION,
+        times: DOT_TRANSITION.times.map(
+          (time, index) => index === 2 || index === 3 || index === 6 || index === 7 ? time + custom * 0.1 : time
+        )
+      }
+    }
+  }),
+  active: (custom) => ({
+    opacity: [1, 0, 0, 1, 1, 0, 0, 1],
+    transition: {
+      opacity: {
+        ...DOT_TRANSITION,
+        repeat: Infinity,
+        times: DOT_TRANSITION.times.map(
+          (time, index) => index === 2 || index === 3 || index === 6 || index === 7 ? time + custom * 0.1 : time
+        )
+      }
+    }
+  })
+};
+var MessageSquareMoreIcon = forwardRef(
+  ({
+    active = false,
+    onMouseEnter,
+    onMouseLeave,
+    className,
+    size = 28,
+    ...props
+  }, ref) => {
+    const controls = useAnimation();
+    const reduceMotion = useReducedMotion();
+    const isControlledRef = useRef(false);
+    const startAnimation = useCallback(() => {
+      if (reduceMotion) {
+        return;
+      }
+      void controls.start(active ? "active" : "animate");
+    }, [active, controls, reduceMotion]);
+    const stopAnimation = useCallback(() => {
+      void controls.start("normal");
+    }, [controls]);
+    useImperativeHandle(ref, () => {
+      isControlledRef.current = true;
+      return {
+        startAnimation,
+        stopAnimation
+      };
+    });
+    useEffect(() => {
+      if (active) {
+        startAnimation();
+        return;
+      }
+      stopAnimation();
+    }, [active, startAnimation, stopAnimation]);
+    const handleMouseEnter = useCallback(
+      (event) => {
+        if (isControlledRef.current) {
+          onMouseEnter?.(event);
+        } else {
+          startAnimation();
+        }
+      },
+      [onMouseEnter, startAnimation]
+    );
+    const handleMouseLeave = useCallback(
+      (event) => {
+        if (isControlledRef.current) {
+          onMouseLeave?.(event);
+        } else {
+          stopAnimation();
+        }
+      },
+      [onMouseLeave, stopAnimation]
+    );
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        className: cn("inline-flex items-center justify-center", className),
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        ...props,
+        children: /* @__PURE__ */ jsxs(
+          "svg",
+          {
+            fill: "none",
+            height: size,
+            stroke: "currentColor",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: "2",
+            viewBox: "0 0 24 24",
+            width: size,
+            xmlns: "http://www.w3.org/2000/svg",
+            children: [
+              /* @__PURE__ */ jsx3("path", { d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" }),
+              /* @__PURE__ */ jsx3(
+                motion.path,
+                {
+                  animate: controls,
+                  custom: 0,
+                  d: "M8 10h.01",
+                  variants: DOT_VARIANTS
+                }
+              ),
+              /* @__PURE__ */ jsx3(
+                motion.path,
+                {
+                  animate: controls,
+                  custom: 1,
+                  d: "M12 10h.01",
+                  variants: DOT_VARIANTS
+                }
+              ),
+              /* @__PURE__ */ jsx3(
+                motion.path,
+                {
+                  animate: controls,
+                  custom: 2,
+                  d: "M16 10h.01",
+                  variants: DOT_VARIANTS
+                }
+              )
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+MessageSquareMoreIcon.displayName = "MessageSquareMoreIcon";
+
+// app/renderer/components/ui/spinner.tsx
+import { Spinner } from "@tutti-os/ui-system";
+
+// shared/agentConversation/components/AgentInteractivePromptSurface.tsx
+import {
+  ShortcutBadge,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger
+} from "@tutti-os/ui-system";
+
+// agent-gui/agentGuiNode/AgentGUIConversation.styles.ts
+var styles = {
+  interactivePrompt: "agent-gui-conversation__interactive-prompt",
+  interactivePromptCard: "agent-gui-conversation__interactive-prompt-card",
+  interactivePromptHeader: "agent-gui-conversation__interactive-prompt-header",
+  interactivePromptLead: "agent-gui-conversation__interactive-prompt-lead",
+  interactivePromptMeta: "agent-gui-conversation__interactive-prompt-meta",
+  interactivePromptQuestion: "agent-gui-conversation__interactive-prompt-question",
+  interactivePromptOptions: "agent-gui-conversation__interactive-prompt-options",
+  interactiveOptionDisplay: "agent-gui-conversation__interactive-option-display",
+  interactiveOptionButton: "agent-gui-conversation__interactive-option-button",
+  interactiveOptionTitle: "agent-gui-conversation__interactive-option-title",
+  interactiveOptionDescription: "agent-gui-conversation__interactive-option-description",
+  interactiveOptionCommandDescription: "agent-gui-conversation__interactive-option-command-description",
+  interactiveOptionCommandTooltip: "agent-gui-conversation__interactive-option-command-tooltip",
+  interactiveOptionShortcut: "agent-gui-conversation__interactive-option-shortcut",
+  interactiveOptionSpinner: "agent-gui-conversation__interactive-option-spinner",
+  interactiveFeedbackComposer: "agent-gui-conversation__interactive-feedback-composer",
+  interactivePromptTextarea: "agent-gui-conversation__interactive-prompt-textarea",
+  interactiveFeedbackSendButton: "agent-gui-conversation__interactive-feedback-send-button",
+  interactivePromptFooter: "agent-gui-conversation__interactive-prompt-footer",
+  interactivePromptActions: "agent-gui-conversation__interactive-prompt-actions",
+  userMessageFlow: "agent-gui-conversation__user-message-flow",
+  assistantMessageFlow: "agent-gui-conversation__assistant-message-flow",
+  messageGroup: "agent-gui-conversation__message-group",
+  userMessageBubble: "agent-gui-conversation__user-message-bubble",
+  assistantMarkdown: "agent-gui-conversation__assistant-markdown"
+};
+var AgentGUIConversation_styles_default = styles;
+
+// shared/agentConversation/components/AgentInteractivePromptSurface.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var COMMAND_TOOLTIP_DELAY_MS = 1e3;
+function AgentInteractivePromptSurface({
+  prompt,
+  edgeGlow = false,
+  embedded = false,
+  keyboardShortcuts = true,
+  isSubmitting,
+  onSubmit,
+  labels
+}) {
+  "use memo";
+  if (prompt.kind === "approval") {
+    return /* @__PURE__ */ jsx4(
+      ApprovalPromptSurface,
+      {
+        prompt,
+        embedded,
+        edgeGlow,
+        keyboardShortcuts,
+        isSubmitting,
+        onSubmit,
+        labels
+      }
+    );
+  }
+  if (prompt.kind === "exit-plan") {
+    return /* @__PURE__ */ jsx4(
+      ExitPlanPromptSurface,
+      {
+        prompt,
+        embedded,
+        edgeGlow,
+        isSubmitting,
+        onSubmit,
+        labels
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx4(
+    AskUserPromptSurface,
+    {
+      prompt,
+      embedded,
+      edgeGlow,
+      isSubmitting,
+      onSubmit,
+      labels
+    }
+  );
+}
+function ApprovalPromptSurface({
+  prompt,
+  embedded = false,
+  edgeGlow = false,
+  keyboardShortcuts = true,
+  isSubmitting,
+  onSubmit,
+  labels
+}) {
+  "use memo";
+  const promptDetails = useMemo2(
+    () => formatToolDetails(prompt.input ?? null),
+    [prompt.input]
+  );
+  const visiblePromptTitle = approvalPromptTitle(
+    prompt.title,
+    promptDetails.length
+  );
+  const details = useMemo2(
+    () => filterDuplicatePromptTitleDetails(promptDetails, visiblePromptTitle),
+    [promptDetails, visiblePromptTitle]
+  );
+  const [submittingOptionId, setSubmittingOptionId] = useState(
+    null
+  );
+  const [pendingFeedbackOptionId, setPendingFeedbackOptionId] = useState(null);
+  const [feedback, setFeedback] = useState("");
+  const feedbackTextareaRef = useRef2(null);
+  const agentHostApi = useOptionalAgentHostApi() ?? getOptionalAgentHostApi();
+  const isDarwin = isDarwinPlatform(agentHostApi?.meta?.platform);
+  const feedbackOptionId = useMemo2(
+    () => approvalFeedbackOptionId(prompt.options),
+    [prompt.options]
+  );
+  const feedbackValue = feedback.trim();
+  useEffect2(() => {
+    setSubmittingOptionId(null);
+    setPendingFeedbackOptionId(null);
+    setFeedback("");
+  }, [prompt.requestId]);
+  useEffect2(() => {
+    if (pendingFeedbackOptionId !== null) {
+      feedbackTextareaRef.current?.focus();
+    }
+  }, [pendingFeedbackOptionId]);
+  const submitOption = useCallback2(
+    (optionId) => {
+      const feedbackOption = feedbackOptionId === optionId;
+      if (feedbackOption && pendingFeedbackOptionId !== optionId) {
+        setFeedback("");
+        setPendingFeedbackOptionId(optionId);
+        return;
+      }
+      setSubmittingOptionId(optionId);
+      onSubmit({
+        requestId: prompt.requestId,
+        ...feedbackOption ? { action: "deny" } : {},
+        optionId,
+        ...feedbackOption && feedbackValue ? { payload: { denyMessage: feedbackValue } } : {}
+      });
+    },
+    [
+      feedbackOptionId,
+      feedbackValue,
+      onSubmit,
+      pendingFeedbackOptionId,
+      prompt.requestId
+    ]
+  );
+  useEffect2(() => {
+    if (!keyboardShortcuts || isSubmitting || submittingOptionId !== null || prompt.options.length === 0) {
+      return void 0;
+    }
+    const handleKeyDown = (event) => {
+      if (!isEnterLikeKey(event) || isEditableKeyboardTarget(event.target) || event.isComposing || event.altKey || event.shiftKey) {
+        return;
+      }
+      const optionIndex = event.metaKey || event.ctrlKey ? 1 : 0;
+      const option = prompt.options[optionIndex];
+      if (!option) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      submitOption(option.id);
+    };
+    window.addEventListener("keydown", handleKeyDown, true);
+    return () => window.removeEventListener("keydown", handleKeyDown, true);
+  }, [
+    isSubmitting,
+    keyboardShortcuts,
+    prompt.options,
+    submitOption,
+    submittingOptionId
+  ]);
+  return /* @__PURE__ */ jsx4("section", { className: interactivePromptClassName(embedded), children: /* @__PURE__ */ jsxs2("div", { className: interactivePromptCardClassName(edgeGlow), children: [
+    /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptLead, children: stripPromptTitlePunctuation(labels.approvalLead) }),
+    visiblePromptTitle ? /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptQuestion, children: visiblePromptTitle }) : null,
+    details.length > 0 ? /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptOptions, children: details.map((detail) => /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        className: AgentGUIConversation_styles_default.interactiveOptionDisplay,
+        children: [
+          /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionTitle, children: detail.label }),
+          /* @__PURE__ */ jsx4(PromptDetailValue, { detail }),
+          detail.meta ? /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionDescription, children: detail.meta }) : null
+        ]
+      },
+      `${detail.label}:${detail.value}`
+    )) }) : null,
+    /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptOptions, children: prompt.options.map((option, optionIndex) => {
+      const showSpinner = submittingOptionId === option.id;
+      const optionSupportsFeedback = feedbackOptionId === option.id;
+      const optionLabel = approvalOptionDisplayLabel(option, {
+        feedback: optionSupportsFeedback
+      });
+      const optionPresentation = approvalOptionVisualPresentation(
+        option,
+        { feedback: optionSupportsFeedback }
+      );
+      const shortcutLabel = approvalOptionShortcutLabel(
+        optionIndex,
+        isDarwin
+      );
+      const showFeedbackComposer = pendingFeedbackOptionId === option.id;
+      if (showFeedbackComposer) {
+        return /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            className: AgentGUIConversation_styles_default.interactiveFeedbackComposer,
+            children: [
+              /* @__PURE__ */ jsx4(
+                "textarea",
+                {
+                  ref: feedbackTextareaRef,
+                  value: feedback,
+                  placeholder: labels.feedbackPlaceholder,
+                  disabled: isSubmitting || submittingOptionId !== null,
+                  className: AgentGUIConversation_styles_default.interactivePromptTextarea,
+                  "aria-label": interactiveOptionLabel(
+                    optionLabel,
+                    option.description
+                  ),
+                  onChange: (event) => setFeedback(event.currentTarget.value),
+                  onKeyDown: (event) => {
+                    if (!keyboardShortcuts || event.key !== "Enter" || !event.metaKey && !event.ctrlKey || event.nativeEvent.isComposing) {
+                      return;
+                    }
+                    event.preventDefault();
+                    if (!feedbackValue) {
+                      feedbackTextareaRef.current?.focus();
+                      return;
+                    }
+                    submitOption(option.id);
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx4(
+                "button",
+                {
+                  type: "button",
+                  className: AgentGUIConversation_styles_default.interactiveFeedbackSendButton,
+                  disabled: isSubmitting || submittingOptionId !== null || !feedbackValue,
+                  "aria-label": labels.sendFeedback,
+                  title: labels.sendFeedback,
+                  "aria-busy": showSpinner,
+                  onClick: () => {
+                    if (!feedbackValue) {
+                      feedbackTextareaRef.current?.focus();
+                      return;
+                    }
+                    submitOption(option.id);
+                  },
+                  children: showSpinner ? /* @__PURE__ */ jsx4(InteractiveOptionSpinner, {}) : /* @__PURE__ */ jsx4(SendFilledIcon, {})
+                }
+              )
+            ]
+          },
+          option.id
+        );
+      }
+      return /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          type: "button",
+          className: AgentGUIConversation_styles_default.interactiveOptionButton,
+          "aria-label": interactiveOptionLabel(
+            optionLabel,
+            option.description
+          ),
+          disabled: isSubmitting || submittingOptionId !== null,
+          onClick: () => submitOption(option.id),
+          children: [
+            /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionTitle, children: optionPresentation.label }),
+            optionPresentation.commandPrefix ? /* @__PURE__ */ jsx4(
+              CommandTextWithTooltip,
+              {
+                value: optionPresentation.commandPrefix,
+                testId: "agent-interactive-command-prefix-option"
+              }
+            ) : null,
+            option.description ? /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionDescription, children: option.description }) : null,
+            keyboardShortcuts && shortcutLabel && !showSpinner ? /* @__PURE__ */ jsx4(
+              ShortcutBadge,
+              {
+                className: AgentGUIConversation_styles_default.interactiveOptionShortcut,
+                "aria-hidden": "true",
+                children: shortcutLabel
+              }
+            ) : null,
+            showSpinner ? /* @__PURE__ */ jsx4(InteractiveOptionSpinner, {}) : null
+          ]
+        },
+        option.id
+      );
+    }) })
+  ] }) });
+}
+function ExitPlanPromptSurface({
+  prompt,
+  embedded = false,
+  edgeGlow = false,
+  isSubmitting,
+  onSubmit,
+  labels
+}) {
+  "use memo";
+  const [feedback, setFeedback] = useState("");
+  const [submittingOptionId, setSubmittingOptionId] = useState(
+    null
+  );
+  const trimmed = feedback.trim();
+  const continueLabel = trimmed === "" ? labels.stayInPlan : labels.sendFeedback;
+  useEffect2(() => {
+    setSubmittingOptionId(null);
+  }, [prompt.requestId]);
+  return /* @__PURE__ */ jsx4("section", { className: interactivePromptClassName(embedded), children: /* @__PURE__ */ jsxs2("div", { className: interactivePromptCardClassName(edgeGlow), children: [
+    /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptLead, children: stripPromptTitlePunctuation(labels.planLead) }),
+    /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptOptions, children: labels.planModes.map((mode) => {
+      const showSpinner = submittingOptionId === mode.id;
+      return /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          type: "button",
+          className: AgentGUIConversation_styles_default.interactiveOptionButton,
+          "aria-label": interactiveOptionLabel(
+            mode.label,
+            mode.description
+          ),
+          disabled: isSubmitting || submittingOptionId !== null,
+          onClick: () => {
+            setSubmittingOptionId(mode.id);
+            onSubmit({
+              requestId: prompt.requestId,
+              action: "allow",
+              optionId: mode.id
+            });
+          },
+          children: [
+            /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionTitle, children: mode.label }),
+            /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionDescription, children: mode.description }),
+            showSpinner ? /* @__PURE__ */ jsx4(InteractiveOptionSpinner, {}) : null
+          ]
+        },
+        mode.id
+      );
+    }) }),
+    /* @__PURE__ */ jsxs2("div", { className: AgentGUIConversation_styles_default.interactivePromptFooter, children: [
+      /* @__PURE__ */ jsx4(
+        "textarea",
+        {
+          value: feedback,
+          placeholder: labels.feedbackPlaceholder,
+          disabled: isSubmitting,
+          className: AgentGUIConversation_styles_default.interactivePromptTextarea,
+          onChange: (event) => setFeedback(event.currentTarget.value)
+        }
+      ),
+      /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptActions, children: /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          disabled: isSubmitting,
+          onClick: () => onSubmit({
+            requestId: prompt.requestId,
+            action: "deny",
+            payload: trimmed ? { denyMessage: trimmed } : void 0
+          }),
+          children: continueLabel
+        }
+      ) })
+    ] })
+  ] }) });
+}
+function AskUserPromptSurface({
+  prompt,
+  embedded = false,
+  edgeGlow = false,
+  isSubmitting,
+  onSubmit,
+  labels
+}) {
+  "use memo";
+  const [index, setIndex] = useState(0);
+  const [selectedByQuestionId, setSelectedByQuestionId] = useState({});
+  const [freeTextByQuestionId, setFreeTextByQuestionId] = useState({});
+  const question = prompt.questions[index] ?? null;
+  const selected = question ? selectedByQuestionId[question.id] ?? [] : [];
+  const freeText = question ? freeTextByQuestionId[question.id] ?? "" : "";
+  const canAdvance = question !== null && (selected.length > 0 || freeText.trim() !== "" || question.options.length === 0);
+  const isLast = index >= prompt.questions.length - 1;
+  const payload = useMemo2(() => {
+    const answersByQuestionId = {};
+    const answers = [];
+    for (const current of prompt.questions) {
+      const chosen = selectedByQuestionId[current.id] ?? [];
+      const other = (freeTextByQuestionId[current.id] ?? "").trim();
+      if (current.multiSelect) {
+        const value2 = other ? [...chosen, other] : chosen;
+        if (value2.length > 0) {
+          answersByQuestionId[current.id] = value2;
+          answers.push(value2.join(", "));
+        }
+        continue;
+      }
+      const value = other || chosen[0];
+      if (value) {
+        answersByQuestionId[current.id] = value;
+        answers.push(value);
+      }
+    }
+    return { answers, answersByQuestionId };
+  }, [freeTextByQuestionId, prompt.questions, selectedByQuestionId]);
+  if (!question) {
+    return /* @__PURE__ */ jsx4("section", { className: interactivePromptClassName(embedded), children: /* @__PURE__ */ jsx4("div", { className: interactivePromptCardClassName(edgeGlow), children: /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        className: `${AgentGUIConversation_styles_default.interactivePromptLead} inline-flex items-center gap-1.5`,
+        children: [
+          /* @__PURE__ */ jsx4(
+            MessageSquareMoreIcon,
+            {
+              size: 15,
+              active: true,
+              "aria-hidden": "true",
+              className: "shrink-0"
+            }
+          ),
+          stripPromptTitlePunctuation(labels.waitingForAnswer)
+        ]
+      }
+    ) }) });
+  }
+  return /* @__PURE__ */ jsx4("section", { className: interactivePromptClassName(embedded), children: /* @__PURE__ */ jsxs2("div", { className: interactivePromptCardClassName(edgeGlow), children: [
+    /* @__PURE__ */ jsxs2("div", { className: AgentGUIConversation_styles_default.interactivePromptHeader, children: [
+      /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactivePromptLead, children: stripPromptTitlePunctuation(question.header) }),
+      /* @__PURE__ */ jsxs2("span", { className: AgentGUIConversation_styles_default.interactivePromptMeta, children: [
+        index + 1,
+        "/",
+        prompt.questions.length
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptQuestion, children: question.question }),
+    question.options.length > 0 ? /* @__PURE__ */ jsx4("div", { className: AgentGUIConversation_styles_default.interactivePromptOptions, children: question.options.map((option) => {
+      const active = selected.includes(option.label);
+      return /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          type: "button",
+          className: AgentGUIConversation_styles_default.interactiveOptionButton,
+          "data-active": active,
+          "aria-label": interactiveOptionLabel(
+            option.label,
+            option.description
+          ),
+          disabled: isSubmitting,
+          onClick: () => {
+            setSelectedByQuestionId((current) => {
+              const existing = current[question.id] ?? [];
+              const next = question.multiSelect ? existing.includes(option.label) ? existing.filter((value) => value !== option.label) : [...existing, option.label] : existing.includes(option.label) ? [] : [option.label];
+              return { ...current, [question.id]: next };
+            });
+          },
+          children: [
+            /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionTitle, children: option.label }),
+            /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionDescription, children: option.description })
+          ]
+        },
+        option.label
+      );
+    }) }) : null,
+    /* @__PURE__ */ jsx4(
+      "textarea",
+      {
+        value: freeText,
+        placeholder: labels.answerPlaceholder,
+        disabled: isSubmitting,
+        className: AgentGUIConversation_styles_default.interactivePromptTextarea,
+        onChange: (event) => {
+          const value = event.currentTarget.value;
+          setFreeTextByQuestionId((current) => ({
+            ...current,
+            [question.id]: value
+          }));
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs2("div", { className: AgentGUIConversation_styles_default.interactivePromptActions, children: [
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          disabled: isSubmitting || index === 0,
+          onClick: () => setIndex((current) => Math.max(current - 1, 0)),
+          children: labels.previousQuestion
+        }
+      ),
+      isLast ? /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          disabled: isSubmitting || Object.keys(payload.answersByQuestionId).length === 0,
+          onClick: () => onSubmit({
+            requestId: prompt.requestId,
+            action: "submit",
+            payload
+          }),
+          children: labels.submitAnswers
+        }
+      ) : /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          disabled: isSubmitting || !canAdvance,
+          onClick: () => setIndex(
+            (current) => Math.min(current + 1, prompt.questions.length - 1)
+          ),
+          children: labels.nextQuestion
+        }
+      )
+    ] })
+  ] }) });
+}
+function isEnterLikeKey(event) {
+  return event.key === "Enter" || event.code === "Enter" || event.code === "NumpadEnter";
+}
+function isEditableKeyboardTarget(target) {
+  if (!(target instanceof HTMLElement)) {
+    return false;
+  }
+  const tagName = target.tagName.toLowerCase();
+  return tagName === "input" || tagName === "textarea" || tagName === "select" || target.isContentEditable;
+}
+function approvalOptionShortcutLabel(optionIndex, isDarwin) {
+  if (optionIndex === 0) {
+    return translate("agentHost.agentGui.shortcutEnter");
+  }
+  if (optionIndex === 1) {
+    return isDarwin ? translate("agentHost.agentGui.shortcutCmdEnter") : translate("agentHost.agentGui.shortcutCtrEnter");
+  }
+  return null;
+}
+function isDarwinPlatform(platform) {
+  if (platform) {
+    return platform === "darwin";
+  }
+  if (typeof navigator === "undefined") {
+    return false;
+  }
+  const userAgentPlatform = "userAgentData" in navigator ? navigator.userAgentData?.platform : void 0;
+  const navigatorPlatform = userAgentPlatform ?? navigator.platform ?? "";
+  return /mac/i.test(navigatorPlatform);
+}
+function InteractiveOptionSpinner() {
+  "use memo";
+  return /* @__PURE__ */ jsx4(
+    Spinner,
+    {
+      className: AgentGUIConversation_styles_default.interactiveOptionSpinner,
+      testId: "agent-interactive-option-spinner"
+    }
+  );
+}
+function SendFilledIcon() {
+  "use memo";
+  return /* @__PURE__ */ jsx4(
+    "svg",
+    {
+      width: "24",
+      height: "24",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      "aria-hidden": "true",
+      children: /* @__PURE__ */ jsx4(
+        "path",
+        {
+          d: "M2.74311 8.80587C2.84592 8.40096 3.14571 8.08844 3.54551 7.97033L18.5197 3.51569C18.9336 3.39383 19.3809 3.5054 19.6881 3.81262C19.9951 4.11984 20.1076 4.56798 19.9857 4.9817L15.5311 19.9559C15.413 20.3557 15.1005 20.6555 14.6956 20.7583C14.2895 20.8597 13.869 20.7438 13.5721 20.4469L10.455 15.1823C10.8585 14.6483 12.1563 12.9094 14.3475 9.96528C14.6086 9.70419 14.6382 9.31168 14.4138 9.08692C14.1891 8.86221 13.796 8.8913 13.5348 9.15252L8.31088 13.0423L3.05316 9.92799C2.7562 9.63104 2.64049 9.21071 2.74311 8.80587Z",
+          fill: "currentColor"
+        }
+      )
+    }
+  );
+}
+function interactivePromptClassName(embedded) {
+  return embedded ? `${AgentGUIConversation_styles_default.interactivePrompt} agent-gui-conversation__interactive-prompt--embedded` : AgentGUIConversation_styles_default.interactivePrompt;
+}
+function interactivePromptCardClassName(edgeGlow) {
+  return edgeGlow ? `${AgentGUIConversation_styles_default.interactivePromptCard} agent-gui-edge-glow` : AgentGUIConversation_styles_default.interactivePromptCard;
+}
+function formatToolDetails(input) {
+  return getPromptToolDetails(input).map((detail) => ({
+    kind: detail.kind,
+    label: promptToolDetailLabel(detail.kind),
+    value: detail.value,
+    ...detail.meta ? { meta: detail.meta } : {}
+  }));
+}
+function PromptDetailValue({
+  detail
+}) {
+  "use memo";
+  if (detail.kind !== "command") {
+    return /* @__PURE__ */ jsx4("span", { className: AgentGUIConversation_styles_default.interactiveOptionDescription, children: detail.value });
+  }
+  return /* @__PURE__ */ jsx4(
+    CommandTextWithTooltip,
+    {
+      value: detail.value,
+      testId: "agent-interactive-command-detail"
+    }
+  );
+}
+function CommandTextWithTooltip({
+  value,
+  testId
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsx4(TooltipProvider, { delayDuration: COMMAND_TOOLTIP_DELAY_MS, children: /* @__PURE__ */ jsxs2(Tooltip, { children: [
+    /* @__PURE__ */ jsx4(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx4(
+      "span",
+      {
+        className: `${AgentGUIConversation_styles_default.interactiveOptionDescription} ${AgentGUIConversation_styles_default.interactiveOptionCommandDescription}`,
+        "data-agent-interactive-command-detail": testId === "agent-interactive-command-detail" ? "true" : void 0,
+        "data-agent-interactive-command-prefix-option": testId === "agent-interactive-command-prefix-option" ? "true" : void 0,
+        children: value
+      }
+    ) }),
+    /* @__PURE__ */ jsx4(TooltipContent, { className: AgentGUIConversation_styles_default.interactiveOptionCommandTooltip, children: value })
+  ] }) });
+}
+function promptToolDetailLabel(kind) {
+  switch (kind) {
+    case "command":
+      return translate("agentHost.agentTool.details.command");
+    case "path":
+      return translate("agentHost.agentTool.details.path");
+    case "query":
+      return translate("agentHost.agentTool.details.query");
+  }
+}
+function filterDuplicatePromptTitleDetails(details, title) {
+  const normalizedTitle = normalizePromptDetailText(title);
+  if (!normalizedTitle) {
+    return details;
+  }
+  return details.filter(
+    (detail) => normalizePromptDetailText(detail.value) !== normalizedTitle
+  );
+}
+function normalizePromptDetailText(value) {
+  return value?.trim() ?? "";
+}
+function isApprovalFeedbackOption(option) {
+  return isDenyApprovalOptionToken(option.id) || isDenyApprovalOptionToken(option.kind);
+}
+function approvalFeedbackOptionId(options) {
+  const explicitFeedbackOption = options.find(
+    (option) => isExplicitFeedbackDenyApprovalOption(option)
+  );
+  if (explicitFeedbackOption) {
+    return explicitFeedbackOption.id;
+  }
+  return options.find(isApprovalFeedbackOption)?.id ?? null;
+}
+function isExplicitFeedbackDenyApprovalOption(option) {
+  for (const value of [option.id, option.kind]) {
+    switch (normalizeApprovalOptionToken(value ?? "")) {
+      case "abort":
+      case "cancel":
+      case "cancelled":
+      case "canceled":
+      case "denywithfeedback":
+      case "rejectwithfeedback":
+        return true;
+      default:
+        break;
+    }
+  }
+  return false;
+}
+function isDenyApprovalOptionToken(value) {
+  switch (normalizeApprovalOptionToken(value ?? "")) {
+    case "abort":
+    case "cancel":
+    case "cancelled":
+    case "canceled":
+    case "deny":
+    case "denied":
+    case "reject":
+    case "rejected":
+    case "rejectonce":
+    case "disallow":
+    case "decline":
+    case "declined":
+    case "no":
+      return true;
+    default:
+      return false;
+  }
+}
+function approvalPromptTitle(value, detailCount) {
+  const title = value.trim();
+  return title && detailCount === 0 && !isPromptRequestIdTitle(title) ? title : null;
+}
+function stripPromptTitlePunctuation(value) {
+  return value.trim().replace(/[.。]+$/u, "");
+}
+function interactiveOptionLabel(label, description) {
+  const trimmedDescription = description?.trim();
+  return trimmedDescription ? `${label} ${trimmedDescription}` : label;
+}
+
+// shared/AgentMessageMarkdown.tsx
+import {
+  createContext as createContext3,
+  startTransition as startTransition2,
+  useCallback as useCallback3,
+  useEffect as useEffect4,
+  useContext as useContext3,
+  memo,
+  useMemo as useMemo3,
+  useState as useState3
+} from "react";
+
+// app/renderer/components/ZoomableImage.tsx
+import {
+  cloneElement
+} from "react";
+import Zoom from "react-medium-image-zoom";
+import { Fragment, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function ZoomableImage({
+  className,
+  wrapElement = "div",
+  ...props
+}) {
+  const { t } = useTranslation();
+  const renderZoomContent = ({
+    buttonUnzoom,
+    img
+  }) => /* @__PURE__ */ jsxs3(Fragment, { children: [
+    img,
+    cloneElement(buttonUnzoom, {
+      className: cn(
+        buttonUnzoom.props.className,
+        "nodrag tsh-desktop-no-drag"
+      )
+    })
+  ] });
+  return /* @__PURE__ */ jsx5(
+    Zoom,
+    {
+      a11yNameButtonZoom: t("common.expandImage"),
+      a11yNameButtonUnzoom: t("common.minimizeImage"),
+      classDialog: "tsh-zoom-dialog nodrag tsh-desktop-no-drag",
+      wrapElement,
+      zoomMargin: 24,
+      ZoomContent: renderZoomContent,
+      children: /* @__PURE__ */ jsx5(
+        "img",
+        {
+          ...props,
+          className: cn("nodrag tsh-desktop-no-drag cursor-zoom-in", className)
+        }
+      )
+    }
+  );
+}
+
+// shared/AgentMessageMarkdown.tsx
+import ReactMarkdown, { defaultUrlTransform } from "react-markdown";
+import rehypeSanitize, {
+  defaultSchema
+} from "rehype-sanitize";
+import remarkGfm from "remark-gfm";
+import {
+  resolveWorkspaceFileExtension,
+  resolveWorkspaceImageMimeType,
+  workspaceFileName as basenameWorkspacePath
+} from "@tutti-os/workspace-file-manager/services";
+
+// shared/utils/websiteUrl.ts
+var ALLOWED_WEBSITE_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+var LIKELY_HOST_PATTERN = /^(localhost|(\d{1,3}\.){3}\d{1,3}|(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,})(?::\d{1,5})?(?:[/?#][^\s]*)?$/i;
+var EXPLICIT_PROTOCOL_PATTERN = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//;
+var LOOPBACK_HOST_PATTERN = /^(localhost|127(?:\.\d{1,3}){3})(?::\d{1,5})?(?:[/?#][^\s]*)?$/i;
+function defaultSchemeForHostInput(value) {
+  return LOOPBACK_HOST_PATTERN.test(value) ? "http" : "https";
+}
+function resolveWebsiteNavigationUrl(rawUrl) {
+  const trimmed = rawUrl.trim();
+  if (trimmed.length === 0) {
+    return { url: null, error: null };
+  }
+  if (EXPLICIT_PROTOCOL_PATTERN.test(trimmed)) {
+    try {
+      const parsed = new URL(trimmed);
+      if (!ALLOWED_WEBSITE_PROTOCOLS.has(parsed.protocol)) {
+        return { url: null, error: `Unsupported protocol: ${parsed.protocol}` };
+      }
+      return { url: parsed.toString(), error: null };
+    } catch {
+      return { url: null, error: "Invalid URL" };
+    }
+  }
+  if (!LIKELY_HOST_PATTERN.test(trimmed)) {
+    return { url: null, error: "Invalid URL" };
+  }
+  try {
+    const parsed = new URL(
+      `${defaultSchemeForHostInput(trimmed)}://${trimmed}`
+    );
+    return { url: parsed.toString(), error: null };
+  } catch {
+    return { url: null, error: "Invalid URL" };
+  }
+}
+
+// actions/workspaceLinkActions.ts
+import {
+  parseWorkspaceIssueMentionHref
+} from "@tutti-os/workspace-issue-manager/core";
+var URL_LIKE_LINK_PATTERN = /^[a-zA-Z][a-zA-Z\d+.-]*:|^#/;
+function resolveWorkspaceFilePathCandidate({
+  path,
+  workspaceRoot,
+  basePath
+}) {
+  const rawPath = decodeWorkspaceLinkPath(path.trim());
+  const root = normalizeWorkspaceFilePath(workspaceRoot?.trim() ?? "");
+  if (!rawPath || !root || isUrlLikeWorkspaceFilePath(rawPath)) {
+    return null;
+  }
+  const normalizedPath = normalizeWorkspaceFilePath(rawPath);
+  const base = normalizeWorkspaceFilePath(basePath?.trim() || root);
+  const resolvedPath = isAbsoluteLocalPath(normalizedPath) ? normalizedPath : normalizeWorkspaceFilePath(`${base}/${normalizedPath}`);
+  if (!isInsideOrEqual(resolvedPath, root) && !isDirectAgentGeneratedImagePath(resolvedPath)) {
+    return null;
+  }
+  return {
+    path: resolvedPath,
+    directoryPath: resolvedPath === root ? root : dirname(resolvedPath),
+    workspaceRoot: root
+  };
+}
+function resolveWorkspaceFileLinkAction({
+  path,
+  workspaceRoot,
+  basePath,
+  source
+}) {
+  const candidate = resolveWorkspaceFilePathCandidate({
+    path,
+    workspaceRoot,
+    basePath
+  });
+  if (!candidate) {
+    return null;
+  }
+  return {
+    type: "open-workspace-file",
+    path: candidate.path,
+    directoryPath: candidate.directoryPath,
+    workspaceRoot: candidate.workspaceRoot,
+    source
+  };
+}
+function resolveWorkspaceUrlLinkAction({
+  url,
+  source
+}) {
+  const resolved = resolveWebsiteNavigationUrl(url);
+  if (!resolved.url || resolved.error) {
+    return null;
+  }
+  return {
+    type: "open-url",
+    url: resolved.url,
+    source
+  };
+}
+function resolveWorkspaceMentionLinkAction({
+  href,
+  source
+}) {
+  const rawHref = href.trim();
+  if (!rawHref.toLowerCase().startsWith("mention://")) {
+    return null;
+  }
+  let url;
+  try {
+    url = new URL(rawHref);
+  } catch {
+    return null;
+  }
+  const workspaceId = url.searchParams.get("workspaceId")?.trim() || "";
+  const targetId = url.searchParams.get("id")?.trim() || "";
+  if (!workspaceId || !targetId) {
+    return null;
+  }
+  if (url.hostname === "agent-session") {
+    const provider = url.searchParams.get("provider")?.trim() || null;
+    return {
+      type: "open-agent-session",
+      workspaceId,
+      agentSessionId: targetId,
+      ...provider ? { provider } : {},
+      source
+    };
+  }
+  if (url.hostname === "workspace-issue") {
+    const parsedIssueMention = parseWorkspaceIssueMentionHref(rawHref);
+    if (!parsedIssueMention) {
+      return null;
+    }
+    return {
+      type: "open-workspace-issue",
+      workspaceId: parsedIssueMention.workspaceId,
+      issueId: parsedIssueMention.issueId,
+      ...parsedIssueMention.mode ? { mode: parsedIssueMention.mode } : {},
+      ...parsedIssueMention.outputDir ? { outputDir: parsedIssueMention.outputDir } : {},
+      ...parsedIssueMention.runId ? { runId: parsedIssueMention.runId } : {},
+      ...parsedIssueMention.taskId ? { taskId: parsedIssueMention.taskId } : {},
+      ...parsedIssueMention.topicId ? { topicId: parsedIssueMention.topicId } : {},
+      source
+    };
+  }
+  return null;
+}
+function resolveWorkspaceLinkAction({
+  href,
+  workspaceRoot,
+  basePath,
+  source
+}) {
+  return resolveWorkspaceMentionLinkAction({ href, source }) ?? resolveWorkspaceFileLinkAction({
+    path: href,
+    workspaceRoot,
+    basePath,
+    source
+  }) ?? resolveWorkspaceUrlLinkAction({ url: href, source });
+}
+function normalizeWorkspaceFilePath(path) {
+  const normalizedPath = path.trim().replaceAll("\\", "/");
+  const drive = /^[A-Za-z]:/.exec(normalizedPath)?.[0] ?? "";
+  const startsWithSlash = normalizedPath.startsWith("/");
+  const pathBody = drive ? normalizedPath.slice(drive.length) : startsWithSlash ? normalizedPath.slice(1) : normalizedPath;
+  const parts = [];
+  for (const part of pathBody.split("/")) {
+    if (!part || part === ".") {
+      continue;
+    }
+    if (part === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  if (drive) {
+    return parts.length > 0 ? `${drive}/${parts.join("/")}` : `${drive}/`;
+  }
+  if (startsWithSlash) {
+    return parts.length > 0 ? `/${parts.join("/")}` : "/";
+  }
+  return parts.join("/");
+}
+function isUrlLikeWorkspaceFilePath(path) {
+  if (path.startsWith("#")) {
+    return true;
+  }
+  if (isWindowsAbsolutePath(path.trim().replaceAll("\\", "/"))) {
+    return false;
+  }
+  return URL_LIKE_LINK_PATTERN.test(path);
+}
+function isAbsoluteLocalPath(path) {
+  return path.startsWith("/") || isWindowsAbsolutePath(path);
+}
+function isWindowsAbsolutePath(path) {
+  return /^[A-Za-z]:\//.test(path);
+}
+function decodeWorkspaceLinkPath(path) {
+  if (!path.includes("%")) {
+    return path;
+  }
+  try {
+    return decodeURI(path);
+  } catch {
+    return path;
+  }
+}
+function dirname(path) {
+  const index = path.lastIndexOf("/");
+  if (index <= 0) {
+    return "/";
+  }
+  return path.slice(0, index);
+}
+function isInsideOrEqual(path, root) {
+  if (root === "/") {
+    return path.startsWith("/");
+  }
+  const comparison = isWindowsAbsolutePath(root) || isWindowsAbsolutePath(path) ? { path: path.toLowerCase(), root: root.toLowerCase() } : { path, root };
+  return comparison.path === comparison.root || comparison.path.startsWith(`${comparison.root}/`);
+}
+function isDirectAgentGeneratedImagePath(path) {
+  if (!isAbsoluteLocalPath(path)) {
+    return false;
+  }
+  const segments = path.split("/").filter(Boolean);
+  const stateRootIndex = segments.findIndex(
+    (segment) => segment === ".nextop" || segment === ".nextop-dev"
+  );
+  if (stateRootIndex < 0) {
+    return false;
+  }
+  const statePath = segments.slice(stateRootIndex);
+  if (statePath[1] !== "agent" || statePath[2] !== "runs" || !statePath.includes("generated_images")) {
+    return false;
+  }
+  return /\.(?:png|jpe?g|gif|webp|bmp)$/i.test(path);
+}
+
+// shared/streamingMarkdownTailStabilizer.ts
+var DEFAULT_MAX_TAIL_CHARS = 4096;
+function stabilizeStreamingMarkdownTail(content, options) {
+  if (!options.streaming || content.length === 0) {
+    return { content, changed: false };
+  }
+  const maxTailChars = Math.max(
+    256,
+    options.maxTailChars ?? DEFAULT_MAX_TAIL_CHARS
+  );
+  const tailStart = Math.max(0, content.length - maxTailChars);
+  const tail = content.slice(tailStart);
+  const fence = findOpenFence(tail);
+  if (fence) {
+    return {
+      content: `${content}
+${fence.marker.repeat(fence.length)}`,
+      changed: true,
+      reason: "open-fence"
+    };
+  }
+  const incompleteLink = stabilizeIncompleteTailLink(content);
+  if (incompleteLink) {
+    return incompleteLink;
+  }
+  const listMarker = stabilizeDanglingListMarker(content);
+  if (listMarker) {
+    return listMarker;
+  }
+  const tableRow = stabilizePartialTableRow(content);
+  if (tableRow) {
+    return tableRow;
+  }
+  const inlineCode = findOpenInlineCodeSpan(tail);
+  if (inlineCode) {
+    return {
+      content: `${content}${"`".repeat(inlineCode.length)}`,
+      changed: true,
+      reason: "open-inline-code"
+    };
+  }
+  const emphasis = stabilizeTrailingEmphasisMarker(content);
+  if (emphasis) {
+    return emphasis;
+  }
+  return { content, changed: false };
+}
+function findOpenFence(tail) {
+  let openFence = null;
+  for (const line of tail.replace(/\r\n?/g, "\n").split("\n")) {
+    const fence = parseFenceLine(line);
+    if (!fence) {
+      continue;
+    }
+    if (!openFence) {
+      openFence = fence;
+      continue;
+    }
+    if (fence.marker === openFence.marker && fence.length >= openFence.length) {
+      openFence = null;
+    }
+  }
+  return openFence;
+}
+function parseFenceLine(line) {
+  let index = 0;
+  while (index < line.length && line[index] === " " && index < 4) {
+    index += 1;
+  }
+  const marker = line[index];
+  if (marker !== "`" && marker !== "~") {
+    return null;
+  }
+  let length = 0;
+  while (line[index + length] === marker) {
+    length += 1;
+  }
+  return length >= 3 ? { marker, length } : null;
+}
+function stabilizeIncompleteTailLink(content) {
+  const lineStart = content.lastIndexOf("\n") + 1;
+  const line = content.slice(lineStart);
+  const linkStart = line.lastIndexOf("[");
+  const imageStart = line.lastIndexOf("![");
+  const openBracketIndex = imageStart >= 0 && imageStart + 1 === linkStart ? imageStart : linkStart;
+  if (openBracketIndex < 0) {
+    return null;
+  }
+  const absoluteOpenIndex = lineStart + openBracketIndex;
+  const suffix = content.slice(absoluteOpenIndex);
+  const closeLabelIndex = suffix.indexOf("]");
+  if (closeLabelIndex < 0) {
+    const label2 = suffix.startsWith("![") ? suffix.slice(2) : suffix.slice(1);
+    return {
+      content: `${content.slice(0, absoluteOpenIndex)}${label2}`,
+      changed: true,
+      reason: "incomplete-link-label"
+    };
+  }
+  if (suffix[closeLabelIndex + 1] !== "(" || suffix.includes(")")) {
+    return null;
+  }
+  const label = suffix.startsWith("![") ? suffix.slice(2, closeLabelIndex) : suffix.slice(1, closeLabelIndex);
+  return {
+    content: `${content.slice(0, absoluteOpenIndex)}${label}`,
+    changed: true,
+    reason: "incomplete-link-target"
+  };
+}
+function stabilizeDanglingListMarker(content) {
+  const lineStart = content.lastIndexOf("\n") + 1;
+  const line = content.slice(lineStart);
+  const trimmed = line.trim();
+  const isBullet = trimmed === "-" || trimmed === "*" || trimmed === "+";
+  const isOrdered = trimmed.length >= 2 && trimmed.endsWith(".") && [...trimmed.slice(0, -1)].every((char) => char >= "0" && char <= "9");
+  if (!isBullet && !isOrdered) {
+    return null;
+  }
+  return {
+    content: content.slice(0, lineStart),
+    changed: true,
+    reason: "dangling-list-marker"
+  };
+}
+function stabilizePartialTableRow(content) {
+  if (content.endsWith("\n")) {
+    return null;
+  }
+  const lines = content.replace(/\r\n?/g, "\n").split("\n");
+  const currentLine = lines.at(-1) ?? "";
+  const previousLine = lines.at(-2) ?? "";
+  if (!currentLine.includes("|") || !previousLine.includes("|")) {
+    return null;
+  }
+  if (currentLine.trimEnd().endsWith("|")) {
+    return null;
+  }
+  if (countChar(previousLine, "|") < 2) {
+    return null;
+  }
+  return {
+    content: `${content} |`,
+    changed: true,
+    reason: "partial-table-row"
+  };
+}
+function findOpenInlineCodeSpan(tail) {
+  const lastParagraph = tail.slice(tail.lastIndexOf("\n\n") + 2);
+  let openLength = 0;
+  for (let index = 0; index < lastParagraph.length; index += 1) {
+    if (lastParagraph[index] !== "`") {
+      continue;
+    }
+    let length = 1;
+    while (lastParagraph[index + length] === "`") {
+      length += 1;
+    }
+    if (length >= 3) {
+      index += length - 1;
+      continue;
+    }
+    openLength = openLength === length ? 0 : length;
+    index += length - 1;
+  }
+  return openLength > 0 ? { length: openLength } : null;
+}
+function stabilizeTrailingEmphasisMarker(content) {
+  const marker = content.at(-1);
+  if (marker !== "*" && marker !== "_") {
+    return null;
+  }
+  const previous = content.at(-2);
+  const nextContent = previous === marker ? content.slice(0, -2) : content.slice(0, -1);
+  return {
+    content: nextContent,
+    changed: true,
+    reason: "trailing-emphasis-marker"
+  };
+}
+function countChar(value, char) {
+  let count = 0;
+  for (const current of value) {
+    if (current === char) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+// shared/useStreamingVisibleText.ts
+import {
+  startTransition,
+  useEffect as useEffect3,
+  useRef as useRef3,
+  useState as useState2
+} from "react";
+var DEFAULT_FRAME_MS = 24;
+var DEFAULT_MAX_CHARS_PER_SECOND = 6e3;
+var DEFAULT_TRAILING_FLUSH_CHARS = 0;
+function useStreamingVisibleText(sourceText, options) {
+  const {
+    enabled,
+    frameMs = DEFAULT_FRAME_MS,
+    maxCharsPerSecond = DEFAULT_MAX_CHARS_PER_SECOND,
+    trailingFlushChars = DEFAULT_TRAILING_FLUSH_CHARS
+  } = options;
+  const [visibleText, setVisibleText] = useState2(sourceText);
+  const sourceRef = useRef3(sourceText);
+  const visibleRef = useRef3(visibleText);
+  const timerRef = useRef3(null);
+  useEffect3(() => {
+    visibleRef.current = visibleText;
+  }, [visibleText]);
+  useEffect3(
+    () => () => {
+      clearStreamingVisibleTextTimer(timerRef);
+    },
+    []
+  );
+  useEffect3(() => {
+    sourceRef.current = sourceText;
+    if (!enabled) {
+      clearStreamingVisibleTextTimer(timerRef);
+      visibleRef.current = sourceText;
+      setVisibleText(sourceText);
+      return;
+    }
+    if (sourceText === visibleRef.current || timerRef.current !== null) {
+      return;
+    }
+    timerRef.current = setTimeout(
+      () => {
+        timerRef.current = null;
+        const nextVisibleText = advanceStreamingVisibleText({
+          visibleText: visibleRef.current,
+          sourceText: sourceRef.current,
+          frameMs,
+          maxCharsPerSecond,
+          trailingFlushChars
+        });
+        if (nextVisibleText === visibleRef.current) {
+          return;
+        }
+        visibleRef.current = nextVisibleText;
+        startTransition(() => {
+          setVisibleText(nextVisibleText);
+        });
+      },
+      Math.max(1, frameMs)
+    );
+    return void 0;
+  }, [
+    enabled,
+    frameMs,
+    maxCharsPerSecond,
+    sourceText,
+    trailingFlushChars,
+    visibleText
+  ]);
+  return enabled ? visibleText : sourceText;
+}
+function advanceStreamingVisibleText({
+  visibleText,
+  sourceText,
+  frameMs = DEFAULT_FRAME_MS,
+  maxCharsPerSecond = DEFAULT_MAX_CHARS_PER_SECOND,
+  trailingFlushChars = DEFAULT_TRAILING_FLUSH_CHARS
+}) {
+  if (visibleText === sourceText) {
+    return visibleText;
+  }
+  const prefixLength = sourceText.startsWith(visibleText) ? visibleText.length : commonPrefixLength(visibleText, sourceText);
+  const stablePrefix = sourceText.slice(0, prefixLength);
+  const remainingLength = sourceText.length - prefixLength;
+  if (remainingLength <= trailingFlushChars) {
+    return sourceText;
+  }
+  const charsPerFrame = Math.max(
+    1,
+    Math.ceil(Math.max(1, maxCharsPerSecond) * Math.max(1, frameMs) / 1e3)
+  );
+  return sourceText.slice(
+    0,
+    Math.min(sourceText.length, stablePrefix.length + charsPerFrame)
+  );
+}
+function commonPrefixLength(left, right) {
+  const maxLength = Math.min(left.length, right.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    if (left.charCodeAt(index) !== right.charCodeAt(index)) {
+      return index;
+    }
+  }
+  return maxLength;
+}
+function clearStreamingVisibleTextTimer(timerRef) {
+  if (timerRef.current === null) {
+    return;
+  }
+  clearTimeout(timerRef.current);
+  timerRef.current = null;
+}
+
+// shared/AgentMessageMarkdown.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var COLLAPSED_LINE_LIMIT = 8;
+var APPROX_CHARS_PER_LINE = 34;
+var DEFERRED_LONG_MARKDOWN_CHAR_THRESHOLD = 4096;
+var STREAMING_MARKDOWN_EMERGENCY_PLAIN_CHAR_THRESHOLD = 96e3;
+var DEFERRED_LONG_MARKDOWN_FALLBACK_DELAY_MS = 80;
+var DEFERRED_LONG_MARKDOWN_IDLE_TIMEOUT_MS = 700;
+var STREAMING_MARKDOWN_FRAME_MS = 24;
+var STREAMING_MARKDOWN_MAX_CHARS_PER_SECOND = 6e3;
+var STREAMING_MARKDOWN_TAIL_FLUSH_CHARS = 0;
+var PLAIN_SESSION_MENTION_AGENT_LABELS = [
+  "Claude Code",
+  "Nexight",
+  "Codex"
+];
+var MARKDOWN_SANITIZE_SCHEMA = {
+  ...defaultSchema,
+  protocols: {
+    ...defaultSchema.protocols,
+    href: [...defaultSchema.protocols?.href ?? [], "mention"]
+  }
+};
+var EMPTY_WORKSPACE_APP_ICONS = [];
+var MarkdownLinkContext = createContext3(false);
+function AgentMessageMarkdown({
+  content,
+  onLinkClick,
+  onLinkAction,
+  workspaceLinkContext = null,
+  workspaceAppIcons = EMPTY_WORKSPACE_APP_ICONS,
+  collapsible = false,
+  expandLabel,
+  className,
+  inline = false,
+  normalizePlainIssueMentionTitle = false,
+  deferLongContentRender = false,
+  enableImageZoom = false,
+  streaming = false
+}) {
+  "use memo";
+  const { t } = useTranslation();
+  const visibleContent = useStreamingVisibleText(content, {
+    enabled: streaming,
+    frameMs: STREAMING_MARKDOWN_FRAME_MS,
+    maxCharsPerSecond: STREAMING_MARKDOWN_MAX_CHARS_PER_SECOND,
+    trailingFlushChars: STREAMING_MARKDOWN_TAIL_FLUSH_CHARS
+  });
+  const stabilizedContent = useMemo3(
+    () => stabilizeStreamingMarkdownTail(visibleContent, {
+      streaming
+    }).content,
+    [streaming, visibleContent]
+  );
+  const workspaceRoot = workspaceLinkContext?.workspaceRoot ?? null;
+  const basePath = workspaceLinkContext?.basePath ?? null;
+  const workspaceLinkSource = workspaceLinkContext?.source ?? null;
+  const [isExpanded, setIsExpanded] = useState3(false);
+  const resolvedExpandLabel = expandLabel ?? t("agentHost.workspaceAgentMessageExpand");
+  const shouldCollapse = collapsible && isLikelyLongerThanLineLimit(stabilizedContent);
+  const isCollapsed = shouldCollapse && !isExpanded;
+  const ContainerTag = inline ? "span" : "div";
+  const contentSignature = useMemo3(
+    () => hashMarkdownProfilerContent(stabilizedContent),
+    [stabilizedContent]
+  );
+  const normalizedContent = useMemo3(
+    () => linkBareLocalAbsolutePaths(
+      normalizeMentionMarkdownLinks(
+        normalizePlainIssueMentionTitle ? normalizePlainIssueMentionTitleContent(
+          normalizePlainSessionMentionTitle(stabilizedContent)
+        ) : normalizePlainSessionMentionTitle(stabilizedContent)
+      )
+    ),
+    [normalizePlainIssueMentionTitle, stabilizedContent]
+  );
+  const isMentionOnly = isMentionOnlyMarkdownContent(normalizedContent);
+  const shouldDeferMarkdownRender = deferLongContentRender && !inline && content.length >= (streaming ? STREAMING_MARKDOWN_EMERGENCY_PLAIN_CHAR_THRESHOLD : DEFERRED_LONG_MARKDOWN_CHAR_THRESHOLD) && !isExpanded;
+  const markdownRenderReady = useDeferredMarkdownRenderReady(
+    contentSignature,
+    shouldDeferMarkdownRender
+  );
+  const handleLinkClick = useCallback3(
+    (href) => {
+      if (workspaceLinkSource && onLinkAction) {
+        const action = resolveWorkspaceLinkAction({
+          href,
+          workspaceRoot,
+          basePath,
+          source: workspaceLinkSource
+        });
+        if (action) {
+          onLinkAction(action);
+          return;
+        }
+      }
+      onLinkClick?.(href);
+    },
+    [basePath, onLinkAction, onLinkClick, workspaceLinkSource, workspaceRoot]
+  );
+  const handleAnchorClickCapture = useCallback3(
+    (event) => {
+      const href = resolveMarkdownAnchorHref(event.target);
+      if (!href) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      handleLinkClick(href);
+    },
+    [handleLinkClick]
+  );
+  const markdownComponents = useMemo3(
+    () => ({
+      a: (props) => /* @__PURE__ */ jsx6(
+        MarkdownLink,
+        {
+          ...props,
+          onLinkClick: handleLinkClick,
+          workspaceAppIcons
+        }
+      ),
+      code: (props) => /* @__PURE__ */ jsx6(MarkdownCode, { ...props, onLinkClick: handleLinkClick }),
+      img: (props) => /* @__PURE__ */ jsx6(MarkdownImage, { ...props, enableZoom: enableImageZoom }),
+      p: (props) => /* @__PURE__ */ jsx6(MarkdownParagraph, { ...props, inline }),
+      ul: MarkdownUnorderedList,
+      ol: MarkdownOrderedList,
+      li: MarkdownListItem
+    }),
+    [enableImageZoom, handleLinkClick, inline, workspaceAppIcons]
+  );
+  return /* @__PURE__ */ jsxs4(
+    ContainerTag,
+    {
+      className: "flex w-full min-w-0 flex-col items-start gap-1",
+      "data-workspace-agent-markdown-shell": "true",
+      children: [
+        /* @__PURE__ */ jsx6(
+          ContainerTag,
+          {
+            className: cn(
+              "relative w-full min-w-0 overflow-x-auto text-[13px] leading-[1.5] text-[var(--text-primary)] [overflow-wrap:anywhere]",
+              "[&_>table:first-child]:mt-0 [&_p]:mb-2 [&_pre]:mb-2 [&_blockquote]:mb-2",
+              "[&_hr]:my-4 [&_hr]:h-0 [&_hr]:border-0 [&_hr]:border-t [&_hr]:border-t-[color-mix(in_srgb,var(--text-primary)_14%,transparent)]",
+              "[&_ul]:my-2 [&_ul]:max-w-full [&_ul]:rounded-[8px] [&_ul]:border [&_ul]:border-[var(--line-2)] [&_ul]:bg-[var(--background-panel)] [&_ul]:px-4 [&_ul]:py-2",
+              "[&_ol]:my-2 [&_ol]:max-w-full [&_ol]:rounded-[8px] [&_ol]:border [&_ol]:border-[var(--line-2)] [&_ol]:bg-[var(--background-panel)] [&_ol]:px-4 [&_ol]:py-2",
+              "[&_li>ul]:mt-1.5 [&_li>ul]:mb-0.5 [&_li>ul]:border-0 [&_li>ul]:px-0 [&_li>ul]:py-1",
+              "[&_li>ol]:mt-1.5 [&_li>ol]:mb-0.5 [&_li>ol]:border-0 [&_li>ol]:px-0 [&_li>ol]:py-1",
+              "[&_table]:my-2 [&_table]:w-max [&_table]:min-w-full [&_table]:max-w-full [&_table]:border-separate [&_table]:border-spacing-0 [&_table]:overflow-hidden [&_table]:rounded-[8px] [&_table]:border [&_table]:border-[var(--line-2)] [&_table]:text-[13px] [&_table]:leading-[1.45]",
+              "[&_th]:max-w-[280px] [&_th]:border-r [&_th]:border-b [&_th]:border-[var(--line-2)] [&_th]:px-2 [&_th]:py-1.5 [&_th]:align-top [&_th]:font-semibold [&_th]:text-[var(--text-primary)] [&_th]:[overflow-wrap:anywhere] [&_th]:bg-[color-mix(in_srgb,var(--background-panel)_94%,var(--text-primary))]",
+              "[&_td]:max-w-[280px] [&_td]:border-r [&_td]:border-b [&_td]:border-[var(--line-2)] [&_td]:px-2 [&_td]:py-1.5 [&_td]:align-top [&_td]:[overflow-wrap:anywhere]",
+              "[&_tr:last-child_th]:border-b-0 [&_tr:last-child_td]:border-b-0 [&_th:last-child]:border-r-0 [&_td:last-child]:border-r-0",
+              "[&_a]:cursor-pointer [&_a]:font-semibold [&_a]:text-[var(--tutti-purple)] [&_a]:no-underline [&_a:hover]:underline [&_a:focus-visible]:underline",
+              "[&_strong]:font-semibold",
+              "[&_code]:inline [&_code]:rounded-[2px] [&_code]:bg-[var(--transparency-block)] [&_code]:px-1 [&_code]:py-[1px] [&_code]:font-[var(--tsh-font-mono)] [&_code]:text-[11px] [&_code]:leading-[1.35] [&_code]:text-[var(--text-primary)] [&_code]:[box-decoration-break:clone] [&_code]:[-webkit-box-decoration-break:clone] [&_code]:[overflow-wrap:anywhere] [&_code]:[word-break:break-word]",
+              "[&_pre]:box-border [&_pre]:overflow-auto [&_pre]:rounded-[6px] [&_pre]:bg-[var(--transparency-block)] [&_pre]:px-2.5 [&_pre]:py-2",
+              "[&_pre_code]:inline [&_pre_code]:h-auto [&_pre_code]:items-normal [&_pre_code]:rounded-none [&_pre_code]:bg-transparent [&_pre_code]:p-0 [&_pre_code]:text-[inherit] [&_pre_code]:leading-[inherit] [&_pre_code]:[white-space:pre-wrap] [&_pre_code]:[overflow-wrap:anywhere] [&_pre_code]:[word-break:break-word]",
+              "[&>*:first-child]:mt-0 [&>*:last-child]:mb-0",
+              inline && "inline min-w-0 overflow-hidden align-baseline [&_p]:inline [&_p]:m-0",
+              shouldCollapse && "overflow-hidden transition-[max-height] duration-220 ease-out",
+              isCollapsed && "max-h-[calc(13px*1.5*8)] overflow-hidden [mask-image:linear-gradient(180deg,black_0%,black_calc(100%_-_36px),transparent_100%)] [-webkit-mask-image:linear-gradient(180deg,black_0%,black_calc(100%_-_36px),transparent_100%)] [&_pre]:overflow-hidden",
+              shouldCollapse && !isCollapsed && "max-h-[72rem]",
+              className
+            ),
+            "data-workspace-agent-markdown": "true",
+            "data-agent-mention-only": isMentionOnly ? "true" : void 0,
+            "data-collapsed": isCollapsed ? "true" : "false",
+            onClickCapture: handleAnchorClickCapture,
+            children: markdownRenderReady ? streaming ? /* @__PURE__ */ jsx6(
+              StreamingMarkdownBlocks,
+              {
+                content: normalizedContent,
+                components: markdownComponents
+              }
+            ) : /* @__PURE__ */ jsx6(
+              ReactMarkdown,
+              {
+                remarkPlugins: [remarkGfm],
+                rehypePlugins: [[rehypeSanitize, MARKDOWN_SANITIZE_SCHEMA]],
+                urlTransform: markdownUrlTransform,
+                components: markdownComponents,
+                children: normalizedContent
+              }
+            ) : /* @__PURE__ */ jsx6(
+              "div",
+              {
+                className: "whitespace-pre-wrap [overflow-wrap:anywhere]",
+                "data-workspace-agent-markdown-deferred": "true",
+                children: normalizedContent
+              }
+            )
+          }
+        ),
+        shouldCollapse && !isExpanded ? /* @__PURE__ */ jsx6(
+          "button",
+          {
+            type: "button",
+            className: "m-0 border-0 bg-transparent p-0 text-[11px] leading-[1.4] font-semibold text-[var(--tutti-purple)] hover:underline focus-visible:underline focus-visible:outline-none",
+            onClick: () => setIsExpanded(true),
+            children: resolvedExpandLabel
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function StreamingMarkdownBlocks({
+  content,
+  components
+}) {
+  const blocks = useMemo3(
+    () => splitStreamingMarkdownBlocks(content),
+    [content]
+  );
+  return /* @__PURE__ */ jsx6(Fragment2, { children: blocks.map((block, index) => /* @__PURE__ */ jsx6(
+    MemoizedMarkdownBlock,
+    {
+      content: block.content,
+      components
+    },
+    `${index}:${hashMarkdownProfilerContent(block.initialKeyContent)}`
+  )) });
+}
+var MemoizedMarkdownBlock = memo(function MemoizedMarkdownBlock2({
+  content,
+  components
+}) {
+  return /* @__PURE__ */ jsx6(
+    ReactMarkdown,
+    {
+      remarkPlugins: [remarkGfm],
+      rehypePlugins: [[rehypeSanitize, MARKDOWN_SANITIZE_SCHEMA]],
+      urlTransform: markdownUrlTransform,
+      components,
+      children: content
+    }
+  );
+});
+function splitStreamingMarkdownBlocks(content) {
+  const normalized = content.replace(/\r\n?/g, "\n");
+  if (!normalized) {
+    return [{ content: "", initialKeyContent: "" }];
+  }
+  const lines = normalized.split("\n");
+  const blocks = [];
+  const current = [];
+  let fence = null;
+  for (const line of lines) {
+    current.push(line);
+    const lineFence = parseStreamingFence(line);
+    if (lineFence) {
+      if (!fence) {
+        fence = lineFence;
+      } else if (lineFence.marker === fence.marker && lineFence.length >= fence.length) {
+        fence = null;
+      }
+      continue;
+    }
+    if (!fence && line.trim() === "") {
+      pushStreamingMarkdownBlock(blocks, current);
+    }
+  }
+  pushStreamingMarkdownBlock(blocks, current);
+  return blocks.length > 0 ? blocks : [{ content: normalized, initialKeyContent: normalized }];
+}
+function pushStreamingMarkdownBlock(blocks, lines) {
+  if (lines.length === 0) {
+    return;
+  }
+  const content = lines.join("\n");
+  if (!content) {
+    lines.length = 0;
+    return;
+  }
+  blocks.push({
+    content,
+    initialKeyContent: content
+  });
+  lines.length = 0;
+}
+function parseStreamingFence(line) {
+  const trimmed = line.trimStart();
+  const marker = trimmed[0];
+  if (marker !== "`" && marker !== "~") {
+    return null;
+  }
+  let length = 0;
+  while (trimmed[length] === marker) {
+    length += 1;
+  }
+  return length >= 3 ? { marker, length } : null;
+}
+function resolveMarkdownAnchorHref(target) {
+  if (!(target instanceof Element)) {
+    return null;
+  }
+  const link = target.closest("[data-agent-link-href],a[href]");
+  if (!(link instanceof HTMLElement)) {
+    return null;
+  }
+  const dataHref = link.dataset.agentLinkHref?.trim();
+  if (dataHref) {
+    return dataHref;
+  }
+  if (link instanceof HTMLAnchorElement) {
+    return link.getAttribute("href")?.trim() || null;
+  }
+  return null;
+}
+function activateMarkdownLink(event, href, onLinkClick) {
+  const target = href.trim();
+  if (!target) {
+    return;
+  }
+  event.preventDefault();
+  event.stopPropagation();
+  onLinkClick?.(target);
+}
+function activateMarkdownLinkFromKey(event, href, onLinkClick) {
+  if (event.key !== "Enter" && event.key !== " ") {
+    return;
+  }
+  activateMarkdownLink(event, href, onLinkClick);
+}
+function activateMarkdownLinkFromPointer(event, href, onLinkClick) {
+  if (event.button !== 0) {
+    return;
+  }
+  activateMarkdownLink(event, href, onLinkClick);
+}
+function useDeferredMarkdownRenderReady(contentSignature, shouldDefer) {
+  const [readySignature, setReadySignature] = useState3(
+    shouldDefer ? null : contentSignature
+  );
+  const renderReady = !shouldDefer || readySignature === contentSignature;
+  useEffect4(() => {
+    if (!shouldDefer) {
+      setReadySignature(contentSignature);
+      return;
+    }
+    let canceled = false;
+    let timeoutId = null;
+    let idleCallbackId = null;
+    const markReady = () => {
+      if (canceled) {
+        return;
+      }
+      startTransition2(() => {
+        setReadySignature(contentSignature);
+      });
+    };
+    if ("requestIdleCallback" in window) {
+      idleCallbackId = window.requestIdleCallback(markReady, {
+        timeout: DEFERRED_LONG_MARKDOWN_IDLE_TIMEOUT_MS
+      });
+    } else {
+      timeoutId = setTimeout(
+        markReady,
+        DEFERRED_LONG_MARKDOWN_FALLBACK_DELAY_MS
+      );
+    }
+    return () => {
+      canceled = true;
+      if (idleCallbackId !== null) {
+        window.cancelIdleCallback(idleCallbackId);
+      }
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [contentSignature, shouldDefer]);
+  return renderReady;
+}
+function hashMarkdownProfilerContent(content) {
+  let hash = 0;
+  for (let index = 0; index < content.length; index += 1) {
+    hash = hash * 31 + content.charCodeAt(index) | 0;
+  }
+  return `${content.length}:${Math.abs(hash)}`;
+}
+function isLikelyLongerThanLineLimit(content) {
+  const normalizedLines = content.replace(/\r\n?/g, "\n").split("\n");
+  if (normalizedLines.length > COLLAPSED_LINE_LIMIT) {
+    return true;
+  }
+  const estimatedLineCount = normalizedLines.reduce((total, line) => {
+    const trimmed = line.trim();
+    const blockSpacing = /^(#{1,6}\s|\s*[-*+]\s|\s*\d+\.\s|>)/.test(trimmed) ? 1 : 0;
+    return total + Math.max(1, Math.ceil(trimmed.length / APPROX_CHARS_PER_LINE)) + blockSpacing;
+  }, 0);
+  return estimatedLineCount > COLLAPSED_LINE_LIMIT;
+}
+function MarkdownLink({
+  node: _node,
+  onClick: _onClick,
+  onLinkClick,
+  workspaceAppIcons,
+  href,
+  ...props
+}) {
+  "use memo";
+  const { t } = useTranslation();
+  const targetHref = href?.trim() ?? "";
+  const mention = targetHref ? parseMentionLink(
+    targetHref,
+    textFromReactNode(props.children),
+    workspaceAppIcons ?? [],
+    t("agentHost.agentGui.workspaceAppFactoryMentionFallback")
+  ) : null;
+  if (mention) {
+    return /* @__PURE__ */ jsx6(
+      MentionLink,
+      {
+        ...props,
+        href: targetHref,
+        mention,
+        onLinkClick
+      }
+    );
+  }
+  const fileMention = targetHref ? parseWorkspaceFileMentionLink(
+    targetHref,
+    textFromReactNode(props.children)
+  ) : null;
+  if (fileMention) {
+    return /* @__PURE__ */ jsx6(
+      WorkspaceFileMentionLink,
+      {
+        ...props,
+        href: targetHref,
+        mention: fileMention,
+        onLinkClick
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx6(MarkdownLinkContext.Provider, { value: true, children: /* @__PURE__ */ jsx6(
+    "a",
+    {
+      ...props,
+      "data-agent-link-href": targetHref,
+      role: "link",
+      tabIndex: 0,
+      onClick: (event) => {
+        activateMarkdownLink(event, targetHref, onLinkClick);
+      },
+      onPointerDown: (event) => {
+        activateMarkdownLinkFromPointer(event, targetHref, onLinkClick);
+      },
+      onKeyDown: (event) => {
+        activateMarkdownLinkFromKey(event, targetHref, onLinkClick);
+      }
+    }
+  ) });
+}
+function parseWorkspaceFileMentionTarget(href) {
+  const target = href.trim();
+  if (!isLocalAbsolutePath(target)) {
+    return null;
+  }
+  let url;
+  try {
+    url = new URL(target, "https://tsh.local");
+  } catch {
+    return null;
+  }
+  const explicitKindValue = url.searchParams.get("kind") ?? url.searchParams.get("refType") ?? url.searchParams.get("entryKind") ?? "";
+  const normalizedKind = explicitKindValue.trim().toLowerCase();
+  const explicitKind = normalizedKind === "folder" || normalizedKind === "directory" ? "directory" : normalizedKind === "file" ? "file" : null;
+  const path = url.pathname.replace(/\/+$/, "");
+  if (!path || path === "/") {
+    return null;
+  }
+  return {
+    path,
+    explicitKind: explicitKind ?? (url.pathname.endsWith("/") ? "directory" : null)
+  };
+}
+function resolveWorkspaceFileMentionEntryKind(path, label, explicitKind) {
+  if (explicitKind) {
+    return explicitKind;
+  }
+  if (resolveWorkspaceFileExtension(path)) {
+    return "file";
+  }
+  const basename = basenameWorkspacePath(path);
+  return basename === label ? "directory" : "file";
+}
+function parseWorkspaceFileMentionLink(href, rawLabel) {
+  const label = rawLabel.trim();
+  const target = parseWorkspaceFileMentionTarget(href);
+  if (!target || !label.startsWith("@")) {
+    return null;
+  }
+  const fileLabel = label.replace(/^@+/, "").trim();
+  if (!fileLabel) {
+    return null;
+  }
+  const entryKind = resolveWorkspaceFileMentionEntryKind(
+    target.path,
+    fileLabel,
+    target.explicitKind
+  );
+  return {
+    label: fileLabel,
+    href: target.path,
+    entryKind,
+    visualKind: resolveAgentWorkspaceFileVisualKind(target.path, {
+      refType: entryKind === "directory" ? "folder" : "file"
+    })
+  };
+}
+function WorkspaceFileMentionLink({
+  onClick: _onClick,
+  onLinkClick,
+  href: _href,
+  mention,
+  ...props
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsxs4(
+    "a",
+    {
+      ...props,
+      className: cn(
+        "tsh-workspace-file-link tsh-agent-object-token tsh-agent-object-token--file",
+        props.className
+      ),
+      "data-agent-file-mention": "true",
+      "data-agent-mention-kind": "file",
+      "data-agent-file-entry-kind": mention.entryKind,
+      "data-agent-file-visual-kind": mention.visualKind,
+      "data-agent-link-href": mention.href,
+      "data-agent-mention-href": mention.href,
+      "aria-label": mention.label,
+      role: "link",
+      tabIndex: 0,
+      onClick: (event) => {
+        activateMarkdownLink(event, mention.href, onLinkClick);
+      },
+      onPointerDown: (event) => {
+        activateMarkdownLinkFromPointer(event, mention.href, onLinkClick);
+      },
+      onKeyDown: (event) => {
+        activateMarkdownLinkFromKey(event, mention.href, onLinkClick);
+      },
+      children: [
+        /* @__PURE__ */ jsx6("span", { className: "tsh-agent-object-token__icon", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx6("span", { className: "tsh-agent-object-token__main", children: mention.label })
+      ]
+    }
+  );
+}
+function MentionLink({
+  onClick: _onClick,
+  onLinkClick,
+  href,
+  mention,
+  ...props
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsxs4(
+    "a",
+    {
+      ...props,
+      className: cn(
+        "tsh-agent-object-token tsh-agent-object-token--entity",
+        props.className
+      ),
+      "data-agent-file-mention": "true",
+      "data-agent-link-href": href,
+      "data-agent-mention-icon-url": mention.iconUrl,
+      "data-agent-mention-href": href,
+      "data-agent-mention-kind": mention.kind,
+      "aria-label": mention.label,
+      role: "link",
+      tabIndex: 0,
+      onClick: (event) => {
+        activateMarkdownLink(event, href, onLinkClick);
+      },
+      onPointerDown: (event) => {
+        activateMarkdownLinkFromPointer(event, href, onLinkClick);
+      },
+      onKeyDown: (event) => {
+        activateMarkdownLinkFromKey(event, href, onLinkClick);
+      },
+      children: [
+        mention.kind === "workspace-app" ? /* @__PURE__ */ jsx6(
+          "span",
+          {
+            className: "grid h-4 w-4 shrink-0 place-items-center overflow-hidden rounded-[4px] bg-block",
+            "aria-hidden": "true",
+            "data-agent-mention-app-icon": "true",
+            "data-workspace-app-icon": "true",
+            children: mention.iconUrl ? /* @__PURE__ */ jsx6(
+              "img",
+              {
+                src: mention.iconUrl,
+                alt: "",
+                className: "h-full w-full object-cover",
+                decoding: "async",
+                loading: "lazy",
+                draggable: false
+              }
+            ) : /* @__PURE__ */ jsx6("span", { className: "tsh-agent-object-token__kind-icon h-4 w-4" })
+          }
+        ) : /* @__PURE__ */ jsx6("span", { className: "tsh-agent-object-token__kind", "aria-hidden": "true", children: /* @__PURE__ */ jsx6(
+          "span",
+          {
+            className: "tsh-agent-object-token__kind-icon",
+            "aria-hidden": "true"
+          }
+        ) }),
+        mention.kind === "session" ? /* @__PURE__ */ jsxs4("span", { className: "tsh-agent-object-token__main", children: [
+          /* @__PURE__ */ jsx6("span", { className: "tsh-agent-object-token__participant", children: mention.participant }),
+          mention.summary ? /* @__PURE__ */ jsxs4("span", { className: "tsh-agent-object-token__summary", children: [
+            " ",
+            mention.summary
+          ] }) : null
+        ] }) : /* @__PURE__ */ jsx6("span", { className: "tsh-agent-object-token__main", children: mention.label })
+      ]
+    }
+  );
+}
+function MarkdownCode({
+  node: _node,
+  children,
+  className,
+  onLinkClick,
+  ...props
+}) {
+  "use memo";
+  const text = textFromReactNode(children).trim();
+  if (!className && onLinkClick && (isLocalAbsolutePath(text) || isHttpUrl(text))) {
+    return /* @__PURE__ */ jsx6("code", { ...props, className, children: /* @__PURE__ */ jsx6(PathLink, { href: text, onLinkClick, children }) });
+  }
+  return /* @__PURE__ */ jsx6("code", { ...props, className, children });
+}
+var cachedMarkdownImages = /* @__PURE__ */ new Map();
+var CACHED_MARKDOWN_IMAGE_REVOKE_DELAY_MS = 250;
+function MarkdownImage({
+  node: _node,
+  src,
+  alt,
+  className,
+  enableZoom = false,
+  ...props
+}) {
+  "use memo";
+  const { t } = useTranslation();
+  const isInsideLink = useContext3(MarkdownLinkContext);
+  const agentHostApi = useOptionalAgentHostApi() ?? getOptionalAgentHostApi();
+  const workspacePath = typeof src === "string" && isLocalAbsolutePath(src) ? src.trim() : null;
+  const readWorkspaceImage = workspacePath ? agentHostApi?.workspace?.readFile : void 0;
+  const canReadWorkspaceImage = Boolean(workspacePath && readWorkspaceImage);
+  const shouldEnableZoom = enableZoom && !isInsideLink;
+  const resolvedSrc = typeof src === "string" ? resolveRenderableMarkdownImageSrc(src) : src;
+  const [state, setState] = useState3(
+    () => canReadWorkspaceImage && workspacePath ? peekCachedMarkdownImageState(workspacePath) ?? { status: "loading" } : null
+  );
+  useEffect4(() => {
+    if (!workspacePath || !readWorkspaceImage) {
+      setState(null);
+      return;
+    }
+    const resolvedWorkspacePath = workspacePath;
+    const resolvedReadWorkspaceImage = readWorkspaceImage;
+    const cachedSrc = retainCachedMarkdownImage(resolvedWorkspacePath);
+    if (cachedSrc) {
+      setState({ status: "ready", src: cachedSrc });
+      return () => {
+        releaseCachedMarkdownImage(resolvedWorkspacePath, cachedSrc);
+      };
+    }
+    const resolvedMimeType = resolveWorkspaceImageMimeType(
+      resolvedWorkspacePath
+    );
+    if (!resolvedMimeType) {
+      setState({
+        status: "error",
+        reason: "unsupported"
+      });
+      return;
+    }
+    const imageMimeType = resolvedMimeType;
+    let canceled = false;
+    let objectUrl = null;
+    setState({ status: "loading" });
+    async function loadWorkspaceImage() {
+      try {
+        const result = await resolvedReadWorkspaceImage({
+          path: resolvedWorkspacePath
+        });
+        if (canceled) {
+          return;
+        }
+        const bytes = result.bytes instanceof Uint8Array ? result.bytes : new Uint8Array(result.bytes);
+        const arrayBuffer = bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        );
+        objectUrl = cacheMarkdownImage(
+          resolvedWorkspacePath,
+          new Blob([arrayBuffer], { type: imageMimeType })
+        );
+        setState({ status: "ready", src: objectUrl });
+      } catch (error) {
+        if (!canceled) {
+          setState({
+            status: "error",
+            reason: "read-failed",
+            detail: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    void loadWorkspaceImage();
+    return () => {
+      canceled = true;
+      if (objectUrl) {
+        releaseCachedMarkdownImage(resolvedWorkspacePath, objectUrl);
+      }
+    };
+  }, [canReadWorkspaceImage, workspacePath]);
+  if (!workspacePath || !readWorkspaceImage) {
+    if (!shouldEnableZoom) {
+      return /* @__PURE__ */ jsx6("img", { ...props, src: resolvedSrc, alt, className });
+    }
+    return /* @__PURE__ */ jsx6(
+      ZoomableImage,
+      {
+        ...props,
+        src: resolvedSrc,
+        alt,
+        className,
+        wrapElement: "span"
+      }
+    );
+  }
+  if (state?.status === "ready") {
+    if (!shouldEnableZoom) {
+      return /* @__PURE__ */ jsx6(
+        "img",
+        {
+          ...props,
+          src: state.src,
+          alt,
+          className: cn(
+            "block max-h-[360px] max-w-full rounded-[8px] border border-[var(--line-2)] bg-[var(--background-panel)] object-contain",
+            className
+          )
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx6(
+      ZoomableImage,
+      {
+        ...props,
+        src: state.src,
+        alt,
+        className: cn(
+          "block max-h-[360px] max-w-full rounded-[8px] border border-[var(--line-2)] bg-[var(--background-panel)] object-contain",
+          className
+        ),
+        wrapElement: "span"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx6("span", { className: "flex min-h-[160px] w-full items-center justify-center rounded-[8px] border border-[var(--line-2)] bg-[var(--background-panel)] px-5 py-5 text-center text-[13px] leading-5 text-[var(--text-tertiary)]", children: state?.status === "error" ? state.reason === "unsupported" ? t("agentHost.workspaceFileManager.previewUnsupported") : t("agentHost.workspaceFileManager.previewReadFailed", {
+    message: state.detail ?? ""
+  }) : t("agentHost.workspaceFileManager.previewLoading") });
+}
+var MARKDOWN_ORDERED_LIST_STYLE = {
+  listStylePosition: "outside",
+  margin: "12px 0 8px",
+  paddingInlineStart: 34,
+  paddingInlineEnd: 16
+};
+var MARKDOWN_UNORDERED_LIST_STYLE = {
+  margin: "12px 0 8px",
+  paddingInlineStart: 0
+};
+var MARKDOWN_LIST_ITEM_STYLE = {
+  margin: "4px 0"
+};
+function MarkdownUnorderedList({
+  node: _node,
+  className,
+  style,
+  ...props
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsx6(
+    "ul",
+    {
+      ...props,
+      className: cn(
+        '[&_li]:relative [&_li]:list-none [&_li]:pl-[34px] [&_li::before]:absolute [&_li::before]:left-4 [&_li::before]:top-[0.78em] [&_li::before]:h-1.5 [&_li::before]:w-1.5 [&_li::before]:-translate-y-1/2 [&_li::before]:rounded-full [&_li::before]:bg-[var(--text-tertiary)] [&_li::before]:content-[""]',
+        className
+      ),
+      style: { ...MARKDOWN_UNORDERED_LIST_STYLE, ...style }
+    }
+  );
+}
+function MarkdownOrderedList({
+  node: _node,
+  style,
+  ...props
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsx6(
+    "ol",
+    {
+      ...props,
+      style: {
+        ...MARKDOWN_ORDERED_LIST_STYLE,
+        listStyleType: "decimal",
+        ...style
+      }
+    }
+  );
+}
+function MarkdownListItem({
+  node: _node,
+  style,
+  ...props
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsx6("li", { ...props, style: { ...MARKDOWN_LIST_ITEM_STYLE, ...style } });
+}
+function MarkdownParagraph({
+  node: _node,
+  inline,
+  ...props
+}) {
+  "use memo";
+  if (inline) {
+    return /* @__PURE__ */ jsx6("span", { ...props });
+  }
+  return /* @__PURE__ */ jsx6("p", { ...props });
+}
+function isLocalAbsolutePath(path) {
+  const candidate = path.trim();
+  return candidate.length > 1 && candidate.startsWith("/") && !candidate.startsWith("//") && !candidate.includes("://") && !/\s/.test(candidate);
+}
+function resolveRenderableMarkdownImageSrc(src) {
+  const trimmed = src.trim();
+  if (!trimmed) {
+    return src;
+  }
+  if (!isLocalAbsolutePath(trimmed) || trimmed.startsWith("/workspace/")) {
+    return src;
+  }
+  return new URL(trimmed, "file://").toString();
+}
+function peekCachedMarkdownImageState(path) {
+  const src = cachedMarkdownImages.get(path)?.objectUrl ?? null;
+  return src ? { status: "ready", src } : null;
+}
+function retainCachedMarkdownImage(path) {
+  const entry = cachedMarkdownImages.get(path);
+  if (!entry) {
+    return null;
+  }
+  entry.refCount += 1;
+  if (entry.revokeTimer) {
+    clearTimeout(entry.revokeTimer);
+    entry.revokeTimer = null;
+  }
+  return entry.objectUrl;
+}
+function cacheMarkdownImage(path, blob) {
+  const entry = cachedMarkdownImages.get(path);
+  if (entry) {
+    entry.refCount += 1;
+    if (entry.revokeTimer) {
+      clearTimeout(entry.revokeTimer);
+      entry.revokeTimer = null;
+    }
+    return entry.objectUrl;
+  }
+  const objectUrl = URL.createObjectURL(blob);
+  cachedMarkdownImages.set(path, {
+    objectUrl,
+    refCount: 1,
+    revokeTimer: null
+  });
+  return objectUrl;
+}
+function releaseCachedMarkdownImage(path, objectUrl) {
+  const entry = cachedMarkdownImages.get(path);
+  if (!entry || entry.objectUrl !== objectUrl) {
+    URL.revokeObjectURL(objectUrl);
+    return;
+  }
+  entry.refCount = Math.max(0, entry.refCount - 1);
+  if (entry.refCount > 0 || entry.revokeTimer) {
+    return;
+  }
+  entry.revokeTimer = setTimeout(() => {
+    const current = cachedMarkdownImages.get(path);
+    if (!current || current.objectUrl !== objectUrl || current.refCount > 0) {
+      return;
+    }
+    cachedMarkdownImages.delete(path);
+    URL.revokeObjectURL(objectUrl);
+  }, CACHED_MARKDOWN_IMAGE_REVOKE_DELAY_MS);
+}
+function isHttpUrl(value) {
+  const candidate = value.trim();
+  if (!candidate || /\s/.test(candidate)) {
+    return false;
+  }
+  try {
+    const url = new URL(candidate);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function linkBareLocalAbsolutePaths(content) {
+  let out = "";
+  for (let index = 0; index < content.length; ) {
+    const markdownLinkEnd = markdownLinkEndIndex(content, index);
+    if (markdownLinkEnd > index) {
+      out += content.slice(index, markdownLinkEnd);
+      index = markdownLinkEnd;
+      continue;
+    }
+    const codeSpanEnd = codeSpanEndIndex(content, index);
+    if (codeSpanEnd > index) {
+      out += content.slice(index, codeSpanEnd);
+      index = codeSpanEnd;
+      continue;
+    }
+    if (isLocalPathStart(content, index)) {
+      const end = bareLocalPathEndIndex(content, index);
+      const rawPath = trimTrailingPathPunctuation(content.slice(index, end));
+      const trailing = content.slice(index + rawPath.length, end);
+      if (isLocalAbsolutePath(rawPath)) {
+        out += `[${escapeMarkdownLinkLabel(rawPath)}](${rawPath})${trailing}`;
+      } else {
+        out += content.slice(index, end);
+      }
+      index = end;
+      continue;
+    }
+    out += content[index];
+    index += 1;
+  }
+  return out;
+}
+function normalizePlainIssueMentionTitleContent(content) {
+  const trimmed = content.trim();
+  if (trimmed !== content || !trimmed.startsWith("@") || trimmed.includes("\n") || markdownLinkEndIndex(trimmed, 0) === trimmed.length) {
+    return content;
+  }
+  const label = trimmed.replace(/^@+/, "").trim();
+  if (!label) {
+    return content;
+  }
+  return `[@${escapeMarkdownLinkLabel(label)}](mention://workspace-issue?source=plain-title)`;
+}
+function normalizeMentionMarkdownLinks(content) {
+  return content.replace(/\]([\t ]*\r?\n[\t ]*)+\((mention:\/\/)/g, "]($2").replace(/\]\((mention:\/\/[A-Za-z0-9.-]+)\)\?([^\s)]+)/g, "]($1?$2)");
+}
+function isMentionOnlyMarkdownContent(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  if (markdownLinkEndIndex(trimmed, 0) !== trimmed.length) {
+    return false;
+  }
+  const labelEnd = trimmed.indexOf("]");
+  return trimmed.slice(labelEnd + 2).startsWith("mention://");
+}
+function normalizePlainSessionMentionTitle(content) {
+  const trimmed = content.trim();
+  if (trimmed !== content || !trimmed.startsWith("@") || trimmed.includes("\n")) {
+    return content;
+  }
+  for (const agentLabel of PLAIN_SESSION_MENTION_AGENT_LABELS) {
+    const separator = ` & ${agentLabel}`;
+    const separatorIndex = trimmed.indexOf(separator);
+    if (separatorIndex <= 1) {
+      continue;
+    }
+    const userLabel = trimmed.slice(1, separatorIndex).trim();
+    const summary = trimmed.slice(separatorIndex + separator.length).trim();
+    if (!userLabel) {
+      continue;
+    }
+    const mentionLabel = [userLabel, agentLabel, summary].filter(Boolean).join(" \xB7 ");
+    return `[@${escapeMarkdownLinkLabel(mentionLabel)}](mention://agent-session?source=plain-title)`;
+  }
+  return content;
+}
+function markdownUrlTransform(value) {
+  return value.startsWith("mention://") ? value : defaultUrlTransform(value);
+}
+function parseMentionLink(href, rawLabel, workspaceAppIcons = [], appFactoryFallbackLabel = "Create app") {
+  let url;
+  try {
+    url = new URL(href);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "mention:") {
+    return null;
+  }
+  const resource = url.hostname.trim().toLowerCase();
+  const kind = resource === "agent-session" ? "session" : resource === "workspace-app" ? "workspace-app" : resource === "workspace-app-factory" ? "workspace-app-factory" : resource === "workspace-issue" ? "workspace-issue" : resource;
+  if (kind !== "session" && kind !== "workspace-app" && kind !== "workspace-app-factory" && kind !== "workspace-issue") {
+    return null;
+  }
+  const label = rawLabel.trim().replace(/^@+/, "").trim() || (kind === "workspace-app-factory" ? appFactoryFallbackLabel : "");
+  if (kind === "workspace-app" || kind === "workspace-app-factory") {
+    const appId = url.searchParams.get("appId")?.trim() || "";
+    const workspaceId = url.searchParams.get("workspaceId")?.trim() || "";
+    return {
+      kind,
+      ...kind === "workspace-app" ? { appId } : {},
+      label,
+      ...kind === "workspace-app" ? {
+        iconUrl: resolveWorkspaceAppMentionIconUrl({
+          appId,
+          workspaceAppIcons,
+          workspaceId
+        })
+      } : {},
+      participant: label,
+      summary: ""
+    };
+  }
+  if (kind === "workspace-issue") {
+    return {
+      kind,
+      label,
+      participant: label,
+      summary: ""
+    };
+  }
+  const sessionLabel = parseSessionMentionLabel(label);
+  return {
+    kind,
+    label,
+    participant: sessionLabel.participant,
+    summary: sessionLabel.summary
+  };
+}
+function resolveWorkspaceAppMentionIconUrl(input) {
+  const appId = input.appId.trim();
+  if (!appId) {
+    return void 0;
+  }
+  const workspaceId = input.workspaceId.trim();
+  const exactMatch = input.workspaceAppIcons.find(
+    (icon) => icon.appId.trim() === appId && (icon.workspaceId?.trim() ?? "") === workspaceId && icon.iconUrl?.trim()
+  );
+  const fallbackMatch = input.workspaceAppIcons.find(
+    (icon) => icon.appId.trim() === appId && icon.iconUrl?.trim()
+  );
+  return exactMatch?.iconUrl?.trim() || fallbackMatch?.iconUrl?.trim() || void 0;
+}
+function parseSessionMentionLabel(label) {
+  const dottedParts = label.split("\xB7").map((part) => part.trim()).filter(Boolean);
+  if (dottedParts.length >= 3) {
+    return {
+      participant: `${dottedParts[0]} & ${dottedParts[1]}`,
+      summary: dottedParts.slice(2).join(" ")
+    };
+  }
+  return {
+    participant: label,
+    summary: ""
+  };
+}
+function markdownLinkEndIndex(content, index) {
+  if (content[index] !== "[") {
+    return -1;
+  }
+  const labelEnd = content.indexOf("]", index + 1);
+  if (labelEnd < 0 || content[labelEnd + 1] !== "(") {
+    return -1;
+  }
+  const hrefEnd = content.indexOf(")", labelEnd + 2);
+  return hrefEnd < 0 ? -1 : hrefEnd + 1;
+}
+function codeSpanEndIndex(content, index) {
+  if (content[index] !== "`") {
+    return -1;
+  }
+  let tickCount = 1;
+  while (content[index + tickCount] === "`") {
+    tickCount += 1;
+  }
+  const fence = "`".repeat(tickCount);
+  const end = content.indexOf(fence, index + tickCount);
+  return end < 0 ? -1 : end + tickCount;
+}
+function isLocalPathStart(content, index) {
+  if (content[index] !== "/" || content[index + 1] === "/") {
+    return false;
+  }
+  const previous = content[index - 1];
+  return previous === void 0 || /\s/.test(previous) || previous === "(" || previous === "[";
+}
+function bareLocalPathEndIndex(content, index) {
+  let end = index;
+  while (end < content.length) {
+    const char = content[end];
+    if (!char || /[\s<>[\](){}"'`]/.test(char)) {
+      break;
+    }
+    end += 1;
+  }
+  return end;
+}
+function trimTrailingPathPunctuation(path) {
+  return path.replace(/[.,;:!?，。；：！？]+$/g, "");
+}
+function escapeMarkdownLinkLabel(label) {
+  return label.replace(/([\\[\]])/g, "\\$1");
+}
+function PathLink({
+  href,
+  children,
+  onLinkClick
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsx6(
+    "a",
+    {
+      className: "cursor-pointer",
+      "data-agent-link-href": href,
+      role: "link",
+      tabIndex: 0,
+      onClick: (event) => {
+        activateMarkdownLink(event, href, onLinkClick);
+      },
+      onPointerDown: (event) => {
+        activateMarkdownLinkFromPointer(event, href, onLinkClick);
+      },
+      onKeyDown: (event) => {
+        activateMarkdownLinkFromKey(event, href, onLinkClick);
+      },
+      children
+    }
+  );
+}
+function textFromReactNode(node) {
+  if (typeof node === "string" || typeof node === "number") {
+    return String(node);
+  }
+  if (Array.isArray(node)) {
+    return node.map(textFromReactNode).join("");
+  }
+  return "";
+}
+
+// app/renderer/assets/icons/user-avatar-placeholder.png
+var user_avatar_placeholder_default = "data:image/png;base64,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";
+
+// shared/workspaceAgentActivityStatusLabel.ts
+function normalizeWorkspaceAgentActivityDisplayStatus(status) {
+  switch ((status ?? "").trim().toLowerCase()) {
+    case "working":
+      return "working";
+    case "waiting":
+      return "waiting";
+    case "idle":
+    case "ready":
+      return "completed";
+    case "completed":
+    case "end":
+      return "completed";
+    case "canceled":
+      return "canceled";
+    case "failed":
+      return "failed";
+    default:
+      return "idle";
+  }
+}
+function workspaceAgentActivityStatusLabel(status, t) {
+  const translateFn = t ?? translate;
+  switch (normalizeWorkspaceAgentActivityDisplayStatus(status)) {
+    case "working":
+      return translateFn("agentHost.workspaceAgentActivityStatusWorking");
+    case "waiting":
+      return translateFn("agentHost.workspaceAgentActivityStatusWaiting");
+    case "idle":
+      return translateFn("agentHost.workspaceAgentActivityStatusIdle");
+    case "completed":
+      return translateFn("agentHost.workspaceAgentActivityStatusEnd");
+    case "canceled":
+      return translateFn("agentHost.workspaceAgentActivityStatusCanceled");
+    case "failed":
+      return translateFn("agentHost.workspaceAgentActivityStatusFailed");
+    default:
+      return String(status);
+  }
+}
+
+// app/renderer/components/ui/custom-scroll-area.tsx
+import {
+  forwardRef as forwardRef2,
+  useCallback as useCallback4,
+  useEffect as useEffect5,
+  useRef as useRef4,
+  useState as useState4
+} from "react";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var MIN_THUMB_HEIGHT = 24;
+function CustomScrollbar({
+  getViewport,
+  className,
+  thumbClassName,
+  testId,
+  thumbTestId,
+  syncKey
+}) {
+  "use memo";
+  const trackRef = useRef4(null);
+  const dragStateRef = useRef4(null);
+  const [scrollbarState, setScrollbarState] = useState4({
+    scrollable: false,
+    thumbHeight: 0,
+    thumbTop: 0
+  });
+  const [dragging, setDragging] = useState4(false);
+  const syncScrollbarState = useCallback4(() => {
+    const viewport = getViewport();
+    if (!viewport) {
+      setScrollbarState({ scrollable: false, thumbHeight: 0, thumbTop: 0 });
+      return;
+    }
+    const { clientHeight, scrollHeight, scrollTop } = viewport;
+    const trackHeight = trackRef.current?.clientHeight ?? clientHeight;
+    const maxScrollTop = Math.max(0, scrollHeight - clientHeight);
+    if (clientHeight <= 0 || trackHeight <= 0 || maxScrollTop <= 0) {
+      setScrollbarState({ scrollable: false, thumbHeight: 0, thumbTop: 0 });
+      return;
+    }
+    const thumbHeight = Math.max(
+      MIN_THUMB_HEIGHT,
+      Math.round(clientHeight / scrollHeight * trackHeight)
+    );
+    const maxThumbTop = Math.max(0, trackHeight - thumbHeight);
+    const thumbTop = Math.round(scrollTop / maxScrollTop * maxThumbTop);
+    setScrollbarState(
+      (previous) => previous.scrollable && previous.thumbHeight === thumbHeight && previous.thumbTop === thumbTop ? previous : { scrollable: true, thumbHeight, thumbTop }
+    );
+  }, [getViewport]);
+  const scrollViewportToThumbTop = useCallback4(
+    (thumbTop) => {
+      const viewport = getViewport();
+      const track = trackRef.current;
+      if (!viewport || !track) {
+        return;
+      }
+      const maxScrollTop = Math.max(
+        0,
+        viewport.scrollHeight - viewport.clientHeight
+      );
+      const maxThumbTop = Math.max(
+        0,
+        track.clientHeight - scrollbarState.thumbHeight
+      );
+      if (maxScrollTop <= 0 || maxThumbTop <= 0) {
+        return;
+      }
+      viewport.scrollTop = clamp(thumbTop, 0, maxThumbTop) / maxThumbTop * maxScrollTop;
+      syncScrollbarState();
+    },
+    [getViewport, scrollbarState.thumbHeight, syncScrollbarState]
+  );
+  const handleTrackMouseDown = useCallback4(
+    (event) => {
+      if (event.button !== 0 || !scrollbarState.scrollable) {
+        return;
+      }
+      const track = trackRef.current;
+      if (!track) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const trackRect = track.getBoundingClientRect();
+      scrollViewportToThumbTop(
+        event.clientY - trackRect.top - scrollbarState.thumbHeight / 2
+      );
+    },
+    [
+      scrollViewportToThumbTop,
+      scrollbarState.scrollable,
+      scrollbarState.thumbHeight
+    ]
+  );
+  const handleThumbMouseDown = useCallback4(
+    (event) => {
+      if (event.button !== 0 || !scrollbarState.scrollable) {
+        return;
+      }
+      const viewport = getViewport();
+      const track = trackRef.current;
+      if (!viewport || !track) {
+        return;
+      }
+      const maxScrollTop = Math.max(
+        0,
+        viewport.scrollHeight - viewport.clientHeight
+      );
+      const maxThumbTop = Math.max(
+        0,
+        track.clientHeight - scrollbarState.thumbHeight
+      );
+      if (maxScrollTop <= 0 || maxThumbTop <= 0) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      dragStateRef.current = {
+        maxScrollTop,
+        maxThumbTop,
+        startClientY: event.clientY,
+        startScrollTop: viewport.scrollTop
+      };
+      setDragging(true);
+    },
+    [getViewport, scrollbarState.scrollable, scrollbarState.thumbHeight]
+  );
+  useEffect5(() => {
+    if (!dragging) {
+      return;
+    }
+    const handleMouseMove = (event) => {
+      const dragState = dragStateRef.current;
+      const viewport = getViewport();
+      if (!dragState || !viewport) {
+        return;
+      }
+      const nextThumbTop = dragState.startScrollTop / dragState.maxScrollTop * dragState.maxThumbTop + (event.clientY - dragState.startClientY);
+      viewport.scrollTop = clamp(nextThumbTop, 0, dragState.maxThumbTop) / dragState.maxThumbTop * dragState.maxScrollTop;
+      syncScrollbarState();
+    };
+    const handleMouseUp = () => {
+      dragStateRef.current = null;
+      setDragging(false);
+    };
+    window.addEventListener("mousemove", handleMouseMove);
+    window.addEventListener("mouseup", handleMouseUp);
+    return () => {
+      window.removeEventListener("mousemove", handleMouseMove);
+      window.removeEventListener("mouseup", handleMouseUp);
+    };
+  }, [dragging, getViewport, syncScrollbarState]);
+  useEffect5(() => {
+    const viewport = getViewport();
+    if (!viewport) {
+      setScrollbarState({ scrollable: false, thumbHeight: 0, thumbTop: 0 });
+      return;
+    }
+    syncScrollbarState();
+    viewport.addEventListener("scroll", syncScrollbarState, { passive: true });
+    const resizeObserver = typeof ResizeObserver !== "undefined" ? new ResizeObserver(syncScrollbarState) : null;
+    resizeObserver?.observe(viewport);
+    const animationFrameId = window.requestAnimationFrame(syncScrollbarState);
+    return () => {
+      window.cancelAnimationFrame(animationFrameId);
+      viewport.removeEventListener("scroll", syncScrollbarState);
+      resizeObserver?.disconnect();
+    };
+  }, [getViewport, syncKey, syncScrollbarState]);
+  return /* @__PURE__ */ jsx7(
+    "div",
+    {
+      ref: trackRef,
+      className: cn("tsh-custom-scrollbar", className),
+      "data-scrollable": scrollbarState.scrollable ? "true" : "false",
+      "data-dragging": dragging ? "true" : "false",
+      "data-testid": testId,
+      "aria-hidden": "true",
+      onMouseDown: handleTrackMouseDown,
+      children: /* @__PURE__ */ jsx7(
+        "div",
+        {
+          className: cn("tsh-custom-scrollbar__thumb", thumbClassName),
+          "data-testid": thumbTestId,
+          onMouseDown: handleThumbMouseDown,
+          style: {
+            height: `${scrollbarState.thumbHeight}px`,
+            transform: `translateY(${scrollbarState.thumbTop}px)`
+          }
+        }
+      )
+    }
+  );
+}
+var CustomScrollArea = forwardRef2(function CustomScrollArea2({
+  children,
+  className,
+  viewportClassName,
+  scrollbarClassName,
+  scrollbarThumbClassName,
+  scrollbarTestId,
+  scrollbarThumbTestId,
+  syncKey,
+  ...viewportProps
+}, forwardedRef) {
+  "use memo";
+  const viewportRef = useRef4(null);
+  const getViewport = useCallback4(() => viewportRef.current, []);
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: cn(
+        "tsh-custom-scroll-area relative min-h-0 min-w-0",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx7(
+          "div",
+          {
+            ref: setRefs(viewportRef, forwardedRef),
+            className: cn(
+              "overflow-auto [scrollbar-width:none] [&::-webkit-scrollbar]:hidden",
+              viewportClassName
+            ),
+            ...viewportProps,
+            children
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          CustomScrollbar,
+          {
+            getViewport,
+            className: scrollbarClassName,
+            thumbClassName: scrollbarThumbClassName,
+            testId: scrollbarTestId,
+            thumbTestId: scrollbarThumbTestId,
+            syncKey: syncKey ?? children
+          }
+        )
+      ]
+    }
+  );
+});
+function setRefs(localRef, forwardedRef) {
+  return (node) => {
+    localRef.current = node;
+    if (typeof forwardedRef === "function") {
+      forwardedRef(node);
+    } else if (forwardedRef) {
+      forwardedRef.current = node;
+    }
+  };
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+export {
+  cn,
+  AgentActivityRuntimeProvider,
+  useAgentActivityRuntime,
+  useOptionalAgentActivityRuntime,
+  useAgentActivitySnapshot,
+  getAgentActivityRuntime,
+  getOptionalAgentActivityRuntime,
+  resetAgentActivityRuntimeForTests,
+  setAgentActivityRuntimeForTests,
+  AgentActivityHostProvider,
+  useAgentHostApi,
+  useOptionalAgentHostApi,
+  getOptionalAgentHostApi,
+  resolveWebsiteNavigationUrl,
+  ZoomableImage,
+  resolveWorkspaceLinkAction,
+  AgentMessageMarkdown,
+  AgentGUIConversation_styles_default,
+  CustomScrollArea,
+  MessageSquareMoreIcon,
+  normalizeManagedAgentProvider,
+  MANAGED_AGENT_ICON_URLS,
+  MANAGED_AGENT_ICON_FALLBACK_URL,
+  managedAgentRoundedIconUrl,
+  approvalOptionDisplayLabel,
+  Spinner,
+  getPromptToolDetails,
+  isPromptRequestIdTitle,
+  AgentInteractivePromptSurface,
+  user_avatar_placeholder_default,
+  workspaceAgentActivityStatusLabel
+};
+//# sourceMappingURL=chunk-FKCXHCPO.js.map