@tutti-os/agent-gui 0.0.9 → 0.0.11

package/dist/chunk-QTZALZIV.js

@@ -0,0 +1,2640 @@
+import {
+  useTranslation
+} from "./chunk-B7K776UD.js";
+import {
+  resolveAgentWorkspaceFileVisualKind
+} from "./chunk-PJP5BUU6.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/agentMcpToolTarget.ts
+function extractAgentMcpToolTarget({
+  input: rawInput,
+  metadata: rawMetadata,
+  payload: rawPayload,
+  toolName
+}) {
+  const payload = objectValue(rawPayload);
+  const input = objectValue(rawInput) ?? objectValue(payload?.input);
+  const metadata = objectValue(rawMetadata) ?? objectValue(payload?.metadata);
+  const toolCall = objectValue(input?.toolCall);
+  const toolCallRawInput = objectValue(toolCall?.rawInput);
+  const request = objectValue(input?.request) ?? objectValue(toolCall?.request);
+  const requestMeta = objectValue(request?._meta);
+  const parsedToolName = parseMcpToolName(
+    firstString(toolName, stringValue(metadata?.toolName))
+  );
+  const server = firstString(
+    stringValue(metadata?.server),
+    stringValue(metadata?.serverName),
+    stringValue(metadata?.mcpServer),
+    stringValue(input?.server),
+    stringValue(input?.server_name),
+    stringValue(input?.serverName),
+    stringValue(input?.mcpServer),
+    stringValue(toolCall?.server),
+    stringValue(toolCall?.server_name),
+    stringValue(toolCall?.serverName),
+    stringValue(toolCallRawInput?.server),
+    stringValue(toolCallRawInput?.server_name),
+    stringValue(toolCallRawInput?.serverName),
+    parsedToolName?.server
+  );
+  const tool = firstString(
+    stringValue(metadata?.toolName),
+    stringValue(metadata?.tool),
+    stringValue(input?.tool),
+    stringValue(input?.toolName),
+    stringValue(toolCall?.tool),
+    stringValue(toolCall?.toolName),
+    stringValue(toolCallRawInput?.tool),
+    stringValue(toolCallRawInput?.toolName),
+    parsedToolName?.tool
+  );
+  if (!server || !tool) {
+    return null;
+  }
+  return {
+    server,
+    tool,
+    displayName: formatAgentMcpToolTarget({ server, tool }),
+    instruction: firstString(
+      formatToolParamsDisplay(requestMeta?.tool_params_display),
+      formatObjectInstruction(requestMeta?.tool_params),
+      formatObjectInstruction(input?.arguments),
+      formatObjectInstruction(toolCallRawInput?.arguments)
+    ) ?? null
+  };
+}
+function formatAgentMcpToolTarget({
+  server,
+  tool
+}) {
+  return `${server} / ${tool}`;
+}
+function parseMcpToolName(value) {
+  const match = value?.match(/^mcp__([^_]+(?:_[^_]+)*)__(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  const server = match[1]?.replace(/_/gu, "-").trim();
+  const tool = match[2]?.trim();
+  return server && tool ? { server, tool } : null;
+}
+function firstString(...values) {
+  return values.find((value) => value !== null && value !== void 0) ?? null;
+}
+function formatToolParamsDisplay(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const parts = value.flatMap((entry) => {
+    const record = objectValue(entry);
+    const name = stringValue(record?.display_name) ?? stringValue(record?.displayName) ?? stringValue(record?.name);
+    const rawValue = record?.value;
+    const formattedValue = formatInstructionValue(rawValue);
+    return name && formattedValue ? [`${name}: ${formattedValue}`] : [];
+  });
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+function formatObjectInstruction(value) {
+  const record = objectValue(value);
+  if (!record) {
+    return stringValue(value);
+  }
+  const parts = Object.entries(record).flatMap(([key, rawValue]) => {
+    const formattedValue = formatInstructionValue(rawValue);
+    return formattedValue ? [`${key}: ${formattedValue}`] : [];
+  });
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+function formatInstructionValue(value) {
+  if (typeof value === "string") {
+    return stringValue(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null) {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const parts = value.flatMap((entry) => {
+      const formattedValue = formatInstructionValue(entry);
+      return formattedValue ? [formattedValue] : [];
+    });
+    return parts.length > 0 ? parts.join(", ") : null;
+  }
+  if (objectValue(value)) {
+    return stableJsonValue(value);
+  }
+  return null;
+}
+function stableJsonValue(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+
+// shared/agentConversation/askUserQuestions.ts
+function normalizeAskUserQuestions(rawQuestions) {
+  return arrayValue(rawQuestions).flatMap((value, index) => {
+    const question = objectValue2(value);
+    if (!question) {
+      return [];
+    }
+    return [
+      {
+        id: stringValue2(question.id) ?? `question-${index + 1}`,
+        header: stringValue2(question.header) ?? `Question ${index + 1}`,
+        question: stringValue2(question.question) ?? stringValue2(question.header) ?? `Question ${index + 1}`,
+        options: arrayValue(question.options).flatMap((optionValue) => {
+          const option = objectValue2(optionValue);
+          const label = stringValue2(option?.label);
+          if (!label) {
+            return [];
+          }
+          return [
+            {
+              label,
+              description: stringValue2(option?.description) ?? ""
+            }
+          ];
+        }),
+        multiSelect: Boolean(question.multiSelect)
+      }
+    ];
+  });
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function objectValue2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+// shared/AgentMessageMarkdown.tsx
+import {
+  createContext as createContext3,
+  startTransition as startTransition2,
+  useCallback,
+  useEffect as useEffect2,
+  useContext as useContext3,
+  memo,
+  useMemo as useMemo2,
+  useState as useState2
+} from "react";
+
+// app/renderer/components/ZoomableImage.tsx
+import {
+  cloneElement
+} from "react";
+import Zoom from "react-medium-image-zoom";
+
+// app/renderer/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// app/renderer/components/ZoomableImage.tsx
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+function ZoomableImage({
+  className,
+  wrapElement = "div",
+  ...props
+}) {
+  const { t } = useTranslation();
+  const renderZoomContent = ({
+    buttonUnzoom,
+    img
+  }) => /* @__PURE__ */ jsxs(Fragment, { children: [
+    img,
+    cloneElement(buttonUnzoom, {
+      className: cn(
+        buttonUnzoom.props.className,
+        "nodrag tsh-desktop-no-drag"
+      )
+    })
+  ] });
+  return /* @__PURE__ */ jsx3(
+    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__ */ jsx3(
+        "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) && !isDirectWorkspaceAppFilePath(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 resource = url.hostname.trim().toLowerCase();
+  const workspaceId = url.searchParams.get("workspaceId")?.trim() || "";
+  const targetId = url.searchParams.get("id")?.trim() || "";
+  if (!workspaceId || !targetId) {
+    return null;
+  }
+  if (resource === "agent-session") {
+    const provider = url.searchParams.get("provider")?.trim() || null;
+    return {
+      type: "open-agent-session",
+      workspaceId,
+      agentSessionId: targetId,
+      ...provider ? { provider } : {},
+      source
+    };
+  }
+  if (resource === "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 === ".tutti" || segment === ".tutti-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);
+}
+function isDirectWorkspaceAppFilePath(path) {
+  if (!isAbsoluteLocalPath(path)) {
+    return false;
+  }
+  const segments = path.split("/").filter(Boolean);
+  const stateRootIndex = segments.findIndex(
+    (segment) => segment === ".tutti" || segment === ".tutti-dev"
+  );
+  if (stateRootIndex < 0) {
+    return false;
+  }
+  const statePath = segments.slice(stateRootIndex);
+  if (statePath[1] !== "apps") {
+    return false;
+  }
+  if (statePath[2] === "workspaces") {
+    return statePath.length > 6 && statePath[5] === "data";
+  }
+  if (statePath[2] === "packages") {
+    return statePath.length > 5;
+  }
+  return false;
+}
+
+// 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,
+  useRef,
+  useState
+} 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] = useState(sourceText);
+  const sourceRef = useRef(sourceText);
+  const visibleRef = useRef(visibleText);
+  const timerRef = useRef(null);
+  useEffect(() => {
+    visibleRef.current = visibleText;
+  }, [visibleText]);
+  useEffect(
+    () => () => {
+      clearStreamingVisibleTextTimer(timerRef);
+    },
+    []
+  );
+  useEffect(() => {
+    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 jsx4, jsxs as jsxs2 } 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 = useMemo2(
+    () => stabilizeStreamingMarkdownTail(visibleContent, {
+      streaming
+    }).content,
+    [streaming, visibleContent]
+  );
+  const workspaceRoot = workspaceLinkContext?.workspaceRoot ?? null;
+  const basePath = workspaceLinkContext?.basePath ?? null;
+  const workspaceLinkSource = workspaceLinkContext?.source ?? null;
+  const [isExpanded, setIsExpanded] = useState2(false);
+  const resolvedExpandLabel = expandLabel ?? t("agentHost.workspaceAgentMessageExpand");
+  const shouldCollapse = collapsible && isLikelyLongerThanLineLimit(stabilizedContent);
+  const isCollapsed = shouldCollapse && !isExpanded;
+  const ContainerTag = inline ? "span" : "div";
+  const contentSignature = useMemo2(
+    () => hashMarkdownProfilerContent(stabilizedContent),
+    [stabilizedContent]
+  );
+  const normalizedContent = useMemo2(
+    () => 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 = useCallback(
+    (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 = useCallback(
+    (event) => {
+      const href = resolveMarkdownAnchorHref(event.target);
+      if (!href) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      handleLinkClick(href);
+    },
+    [handleLinkClick]
+  );
+  const markdownComponents = useMemo2(
+    () => ({
+      a: (props) => /* @__PURE__ */ jsx4(
+        MarkdownLink,
+        {
+          ...props,
+          onLinkClick: handleLinkClick,
+          workspaceAppIcons
+        }
+      ),
+      code: (props) => /* @__PURE__ */ jsx4(MarkdownCode, { ...props, onLinkClick: handleLinkClick }),
+      img: (props) => /* @__PURE__ */ jsx4(MarkdownImage, { ...props, enableZoom: enableImageZoom }),
+      p: (props) => /* @__PURE__ */ jsx4(MarkdownParagraph, { ...props, inline }),
+      ul: MarkdownUnorderedList,
+      ol: MarkdownOrderedList,
+      li: MarkdownListItem
+    }),
+    [enableImageZoom, handleLinkClick, inline, workspaceAppIcons]
+  );
+  return /* @__PURE__ */ jsxs2(
+    ContainerTag,
+    {
+      className: "flex w-full min-w-0 flex-col items-start gap-1",
+      "data-workspace-agent-markdown-shell": "true",
+      children: [
+        /* @__PURE__ */ jsx4(
+          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__ */ jsx4(
+              StreamingMarkdownBlocks,
+              {
+                content: normalizedContent,
+                components: markdownComponents
+              }
+            ) : /* @__PURE__ */ jsx4(
+              ReactMarkdown,
+              {
+                remarkPlugins: [remarkGfm],
+                rehypePlugins: [[rehypeSanitize, MARKDOWN_SANITIZE_SCHEMA]],
+                urlTransform: markdownUrlTransform,
+                components: markdownComponents,
+                children: normalizedContent
+              }
+            ) : /* @__PURE__ */ jsx4(
+              "div",
+              {
+                className: "whitespace-pre-wrap [overflow-wrap:anywhere]",
+                "data-workspace-agent-markdown-deferred": "true",
+                children: normalizedContent
+              }
+            )
+          }
+        ),
+        shouldCollapse && !isExpanded ? /* @__PURE__ */ jsx4(
+          "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 = useMemo2(
+    () => splitStreamingMarkdownBlocks(content),
+    [content]
+  );
+  return /* @__PURE__ */ jsx4(Fragment2, { children: blocks.map((block, index) => /* @__PURE__ */ jsx4(
+    MemoizedMarkdownBlock,
+    {
+      content: block.content,
+      components
+    },
+    `${index}:${hashMarkdownProfilerContent(block.initialKeyContent)}`
+  )) });
+}
+var MemoizedMarkdownBlock = memo(function MemoizedMarkdownBlock2({
+  content,
+  components
+}) {
+  return /* @__PURE__ */ jsx4(
+    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] = useState2(
+    shouldDefer ? null : contentSignature
+  );
+  const renderReady = !shouldDefer || readySignature === contentSignature;
+  useEffect2(() => {
+    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__ */ jsx4(
+      MentionLink,
+      {
+        ...props,
+        href: targetHref,
+        mention,
+        onLinkClick
+      }
+    );
+  }
+  const fileMention = targetHref ? parseWorkspaceFileMentionLink(
+    targetHref,
+    textFromReactNode(props.children)
+  ) : null;
+  if (fileMention) {
+    return /* @__PURE__ */ jsx4(
+      WorkspaceFileMentionLink,
+      {
+        ...props,
+        href: targetHref,
+        mention: fileMention,
+        onLinkClick
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx4(MarkdownLinkContext.Provider, { value: true, children: /* @__PURE__ */ jsx4(
+    "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__ */ jsxs2(
+    "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__ */ jsx4("span", { className: "tsh-agent-object-token__icon", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx4("span", { className: "tsh-agent-object-token__main", children: mention.label })
+      ]
+    }
+  );
+}
+function MentionLink({
+  onClick: _onClick,
+  onLinkClick,
+  href,
+  mention,
+  ...props
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsxs2(
+    "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__ */ jsx4(
+          "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__ */ jsx4(
+              "img",
+              {
+                src: mention.iconUrl,
+                alt: "",
+                className: "h-full w-full object-cover",
+                decoding: "async",
+                loading: "lazy",
+                draggable: false
+              }
+            ) : /* @__PURE__ */ jsx4("span", { className: "tsh-agent-object-token__kind-icon h-4 w-4" })
+          }
+        ) : /* @__PURE__ */ jsx4("span", { className: "tsh-agent-object-token__kind", "aria-hidden": "true", children: /* @__PURE__ */ jsx4(
+          "span",
+          {
+            className: "tsh-agent-object-token__kind-icon",
+            "aria-hidden": "true"
+          }
+        ) }),
+        mention.kind === "session" ? /* @__PURE__ */ jsxs2("span", { className: "tsh-agent-object-token__main", children: [
+          /* @__PURE__ */ jsx4("span", { className: "tsh-agent-object-token__participant", children: mention.participant }),
+          mention.summary ? /* @__PURE__ */ jsxs2("span", { className: "tsh-agent-object-token__summary", children: [
+            " ",
+            mention.summary
+          ] }) : null
+        ] }) : /* @__PURE__ */ jsx4("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__ */ jsx4("code", { ...props, className, children: /* @__PURE__ */ jsx4(PathLink, { href: text, onLinkClick, children }) });
+  }
+  return /* @__PURE__ */ jsx4("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] = useState2(
+    () => canReadWorkspaceImage && workspacePath ? peekCachedMarkdownImageState(workspacePath) ?? { status: "loading" } : null
+  );
+  useEffect2(() => {
+    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__ */ jsx4("img", { ...props, src: resolvedSrc, alt, className });
+    }
+    return /* @__PURE__ */ jsx4(
+      ZoomableImage,
+      {
+        ...props,
+        src: resolvedSrc,
+        alt,
+        className,
+        wrapElement: "span"
+      }
+    );
+  }
+  if (state?.status === "ready") {
+    if (!shouldEnableZoom) {
+      return /* @__PURE__ */ jsx4(
+        "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__ */ jsx4(
+      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__ */ jsx4("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__ */ jsx4(
+    "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__ */ jsx4(
+    "ol",
+    {
+      ...props,
+      style: {
+        ...MARKDOWN_ORDERED_LIST_STYLE,
+        listStyleType: "decimal",
+        ...style
+      }
+    }
+  );
+}
+function MarkdownListItem({
+  node: _node,
+  style,
+  ...props
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsx4("li", { ...props, style: { ...MARKDOWN_LIST_ITEM_STYLE, ...style } });
+}
+function MarkdownParagraph({
+  node: _node,
+  inline,
+  ...props
+}) {
+  "use memo";
+  if (inline) {
+    return /* @__PURE__ */ jsx4("span", { ...props });
+  }
+  return /* @__PURE__ */ jsx4("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__ */ jsx4(
+    "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 "";
+}
+
+// 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",
+  messageCopyButton: "agent-gui-conversation__message-copy-button",
+  userMessageBubble: "agent-gui-conversation__user-message-bubble",
+  assistantMarkdown: "agent-gui-conversation__assistant-markdown"
+};
+var AgentGUIConversation_styles_default = styles;
+
+// app/renderer/components/icons/MessageSquareMoreIcon.tsx
+import {
+  forwardRef,
+  useCallback as useCallback2,
+  useEffect as useEffect3,
+  useImperativeHandle,
+  useRef as useRef2
+} from "react";
+import {
+  motion,
+  useAnimation,
+  useReducedMotion
+} from "framer-motion";
+import { jsx as jsx5, jsxs as jsxs3 } 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 = useRef2(false);
+    const startAnimation = useCallback2(() => {
+      if (reduceMotion) {
+        return;
+      }
+      void controls.start(active ? "active" : "animate");
+    }, [active, controls, reduceMotion]);
+    const stopAnimation = useCallback2(() => {
+      void controls.start("normal");
+    }, [controls]);
+    useImperativeHandle(ref, () => {
+      isControlledRef.current = true;
+      return {
+        startAnimation,
+        stopAnimation
+      };
+    });
+    useEffect3(() => {
+      if (active) {
+        startAnimation();
+        return;
+      }
+      stopAnimation();
+    }, [active, startAnimation, stopAnimation]);
+    const handleMouseEnter = useCallback2(
+      (event) => {
+        if (isControlledRef.current) {
+          onMouseEnter?.(event);
+        } else {
+          startAnimation();
+        }
+      },
+      [onMouseEnter, startAnimation]
+    );
+    const handleMouseLeave = useCallback2(
+      (event) => {
+        if (isControlledRef.current) {
+          onMouseLeave?.(event);
+        } else {
+          stopAnimation();
+        }
+      },
+      [onMouseLeave, stopAnimation]
+    );
+    return /* @__PURE__ */ jsx5(
+      "div",
+      {
+        className: cn("inline-flex items-center justify-center", className),
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        ...props,
+        children: /* @__PURE__ */ jsxs3(
+          "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__ */ jsx5("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__ */ jsx5(
+                motion.path,
+                {
+                  animate: controls,
+                  custom: 0,
+                  d: "M8 10h.01",
+                  variants: DOT_VARIANTS
+                }
+              ),
+              /* @__PURE__ */ jsx5(
+                motion.path,
+                {
+                  animate: controls,
+                  custom: 1,
+                  d: "M12 10h.01",
+                  variants: DOT_VARIANTS
+                }
+              ),
+              /* @__PURE__ */ jsx5(
+                motion.path,
+                {
+                  animate: controls,
+                  custom: 2,
+                  d: "M16 10h.01",
+                  variants: DOT_VARIANTS
+                }
+              )
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+MessageSquareMoreIcon.displayName = "MessageSquareMoreIcon";
+
+// app/renderer/components/ui/custom-scroll-area.tsx
+import {
+  forwardRef as forwardRef2,
+  useCallback as useCallback3,
+  useEffect as useEffect4,
+  useRef as useRef3,
+  useState as useState3
+} from "react";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var MIN_THUMB_HEIGHT = 24;
+function CustomScrollbar({
+  getViewport,
+  className,
+  thumbClassName,
+  testId,
+  thumbTestId,
+  syncKey
+}) {
+  "use memo";
+  const trackRef = useRef3(null);
+  const dragStateRef = useRef3(null);
+  const [scrollbarState, setScrollbarState] = useState3({
+    scrollable: false,
+    thumbHeight: 0,
+    thumbTop: 0
+  });
+  const [dragging, setDragging] = useState3(false);
+  const syncScrollbarState = useCallback3(() => {
+    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 = useCallback3(
+    (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 = useCallback3(
+    (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 = useCallback3(
+    (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]
+  );
+  useEffect4(() => {
+    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]);
+  useEffect4(() => {
+    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__ */ jsx6(
+    "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__ */ jsx6(
+        "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 = useRef3(null);
+  const getViewport = useCallback3(() => viewportRef.current, []);
+  return /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      className: cn(
+        "tsh-custom-scroll-area relative min-h-0 min-w-0",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx6(
+          "div",
+          {
+            ref: setRefs(viewportRef, forwardedRef),
+            className: cn(
+              "overflow-auto [scrollbar-width:none] [&::-webkit-scrollbar]:hidden",
+              viewportClassName
+            ),
+            ...viewportProps,
+            children
+          }
+        ),
+        /* @__PURE__ */ jsx6(
+          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,
+  extractAgentMcpToolTarget,
+  normalizeAskUserQuestions,
+  resolveWebsiteNavigationUrl,
+  ZoomableImage,
+  resolveWorkspaceLinkAction,
+  AgentMessageMarkdown,
+  AgentGUIConversation_styles_default,
+  CustomScrollArea,
+  MessageSquareMoreIcon
+};
+//# sourceMappingURL=chunk-QTZALZIV.js.map