Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

61.2 KB
Raw Blame
/// <reference types="@testing-library/jest-dom/vitest" />
import React from "react"
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react"
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"

const apiRequestMock = vi.hoisted(() => vi.fn())
const clipboardWriteTextMock = vi.hoisted(() => vi.fn())
const appContextMock = vi.hoisted(() => ({
  dispatch: vi.fn(),
  filesDisabled: false,
  openFilePreview: vi.fn(),
}))

vi.mock("next/navigation", () => ({
  useRouter: () => ({ push: vi.fn() }),
}))

vi.mock("@/contexts/i18n-context", () => ({
  useI18n: () => ({
    t: (key: string, vars?: Record<string, string | number>) => {
      if (vars?.tool) return `${key}:${vars.tool}`
      if (vars?.connector) return `${key}:${vars.connector}`
      if (vars?.worker) return `${key}:${vars.worker}`
      if (vars && "count" in vars) return `${key}:${vars.count}`
      return key
    },
  }),
}))

const toastErrorMock = vi.hoisted(() => vi.fn())
vi.mock("@/components/ui/sonner", () => ({
  toast: { error: toastErrorMock },
}))

vi.mock("@/contexts/app-context-chat", () => ({
  useApp: () => appContextMock,
}))

vi.mock("@/lib/utils", async () => {
  const actual = await vi.importActual<typeof import("@/lib/utils")>("@/lib/utils")
  return {
    ...actual,
    getApiUrl: () => "http://api.local",
  }
})

vi.mock("@/lib/api-wrapper", () => ({
  apiRequest: apiRequestMock,
}))

vi.mock("@/components/file/docx-preview-renderer", () => ({
  DocxPreviewRenderer: ({ base64Content }: { base64Content: string }) => (
    <div data-testid="docx-preview">{base64Content}</div>
  ),
}))

vi.mock("@/components/file/excel-preview-renderer", () => ({
  ExcelPreviewRenderer: ({ base64Content }: { base64Content: string }) => (
    <div data-testid="excel-preview">{base64Content}</div>
  ),
}))

vi.mock("@/components/file/pptx-preview-renderer", () => ({
  PptxPreviewRenderer: ({
    base64Content,
    fileId,
  }: {
    base64Content?: string
    fileId?: string
  }) => <div data-testid="pptx-preview">{base64Content ?? fileId ?? ""}</div>,
}))

import { TraceEventRenderer } from "./TraceEventRenderer"

describe("TraceEventRenderer", () => {
  it("renders a failed DAG end correctly both live and after replay", () => {
    const events = [
      {
        event_id: "export-start",
        event_type: "dag_step_start",
        step_id: "export",
        timestamp: 1000,
        data: { step_name: "Export verified data" },
      },
      {
        event_id: "export-end",
        event_type: "dag_step_end",
        step_id: "export",
        timestamp: 2000,
        data: { status: "completed", result: "Verified output" },
      },
      {
        event_id: "verify-start",
        event_type: "dag_step_start",
        step_id: "verify",
        timestamp: 3000,
        data: { step_name: "Verify remaining data" },
      },
      {
        event_id: "verify-end",
        event_type: "dag_step_end",
        step_id: "verify",
        timestamp: 4000,
        data: { status: "failed", error: "Iteration limit reached" },
      },
    ]
    const { container, rerender, unmount } = render(
      <TraceEventRenderer events={events.slice(0, -1)} taskStatus="running" />,
    )
    expect(screen.getByRole("button", { name: "Verify remaining data" })).toBeInTheDocument()

    rerender(<TraceEventRenderer events={events} taskStatus="running" />)
    const assertStepOutcomes = () => {
      const successful = screen.getByRole("button", { name: "Export verified data" })
      const failed = screen.getByRole("button", { name: "Verify remaining data" })
      expect(successful.querySelector(".text-green-500")).not.toBeNull()
      expect(failed.querySelector(".text-red-500")).not.toBeNull()
      expect(failed.querySelector(".text-green-500")).toBeNull()
      if (failed.getAttribute("aria-expanded") === "false") fireEvent.click(failed)
      fireEvent.click(screen.getByRole("button", { name: /traceEventRenderer.executionFailed/ }))
      expect(screen.getByText("Iteration limit reached")).toBeInTheDocument()
    }
    assertStepOutcomes()
    expect(container.querySelector(".animate-spin")).toBeNull()

    // A successful partial handoff completes the task, not its failed step.
    unmount()
    render(<TraceEventRenderer events={events} taskStatus="completed" />)
    assertStepOutcomes()
  })

  describe("interrupted process", () => {
    const events = [
      { event_id: "start", event_type: "react_task_start", step_id: "s1", timestamp: 1000, data: {} },
      {
        event_id: "tool",
        event_type: "tool_execution_start",
        step_id: "s1",
        timestamp: 2000,
        data: { tool_name: "web_search", tool_args: { query: "interrupted-probe" } },
      },
    ]

    it("renders an interrupted process as a distinct, named, non-error state", () => {
      const { container } = render(<TraceEventRenderer events={events} taskStatus="interrupted" />)

      expect(container.querySelector(".animate-spin")).toBeNull()
      expect(container.querySelector(".text-red-500")).toBeNull()
      expect(screen.queryByText("traceEventRenderer.unknownError")).toBeNull()

      const step = screen.getByRole("button", { name: /agent\.layout\.status\.interrupted/ })
      const icon = step.querySelector("svg[data-icon='interrupted']")
      expect(icon).not.toBeNull()
      // CircleSlash draws a diagonal bar; the Info glyph used for failed and
      // paused steps draws a vertical stem instead.
      expect(icon?.querySelector("line[x1='9'][y1='15'][x2='15'][y2='9']")).not.toBeNull()
      expect(icon?.querySelector("path[d='M12 16v-4']")).toBeNull()
    })

    it("collapses an action once its process becomes interrupted", async () => {
      const { rerender } = render(<TraceEventRenderer events={events} taskStatus="running" />)
      expect(screen.getByText("traceEventRenderer.searchQuery")).toBeInTheDocument()

      rerender(<TraceEventRenderer events={events} taskStatus="interrupted" />)
      await waitFor(() => {
        expect(screen.queryByText("traceEventRenderer.searchQuery")).toBeNull()
      })
    })
  })

  it("ignores null, primitive, and malformed trace event entries", () => {
    expect(() => render(
      <TraceEventRenderer
        events={[
          null,
          42,
          "not-an-event",
          { event_type: 17, data: "not-an-object" },
          { event_type: "agent_progress", data: null },
        ] as unknown as React.ComponentProps<typeof TraceEventRenderer>["events"]}
      />,
    )).not.toThrow()
  })

  beforeEach(() => {
    window.scrollTo = vi.fn()
    appContextMock.filesDisabled = false
    appContextMock.dispatch.mockReset()
    appContextMock.openFilePreview.mockReset()
    clipboardWriteTextMock.mockReset()
    toastErrorMock.mockReset()
    Object.defineProperty(navigator, "clipboard", {
      configurable: true,
      value: { writeText: clipboardWriteTextMock },
    })
  })

  afterEach(() => {
    cleanup()
    apiRequestMock.mockReset()
    vi.restoreAllMocks()
  })

  it("reports a copy that never reached the clipboard instead of claiming it", async () => {
    clipboardWriteTextMock.mockRejectedValue(new DOMException("blocked", "NotAllowedError"))
    // jsdom has no execCommand; install a failing one so the legacy fallback
    // copyToClipboard takes after a refused Clipboard API also fails.
    const previous = Object.getOwnPropertyDescriptor(document, "execCommand")
    Object.defineProperty(document, "execCommand", { configurable: true, value: () => false })
    try {
      render(
        <TraceEventRenderer events={[
          { event_id: "start", event_type: "react_task_start", step_id: "copy-step", timestamp: 1000, data: {} },
          { event_id: "tool", event_type: "tool_execution_start", step_id: "copy-step", timestamp: 2000,
            data: { tool_name: "inspect_output", tool_args: { query: "copy feedback" } } },
        ]} />,
      )
      const button = screen.getAllByTitle("traceEventRenderer.copy")[0]

      await act(async () => { fireEvent.click(button) })

      expect(clipboardWriteTextMock).toHaveBeenCalledTimes(1)
      expect(button.querySelector("svg.text-green-500")).toBeNull()
      expect(toastErrorMock).toHaveBeenCalledWith("common.copyFailed")
    } finally {
      if (previous) Object.defineProperty(document, "execCommand", previous)
      else delete (document as { execCommand?: unknown }).execCommand
    }
  })

  it.each(["expire", "unmount"])("cleans up the copy feedback timer on %s", async (finish) => {
    const timeoutSpy = vi.spyOn(globalThis, "setTimeout")
    const clearSpy = vi.spyOn(globalThis, "clearTimeout")
    try {
      const { unmount } = render(
        <TraceEventRenderer events={[
          { event_id: "start", event_type: "react_task_start", step_id: "copy-step", timestamp: 1000, data: {} },
          { event_id: "tool", event_type: "tool_execution_start", step_id: "copy-step", timestamp: 2000,
            data: { tool_name: "inspect_output", tool_args: { query: "copy feedback" } } },
        ]} />,
      )
      const button = screen.getAllByTitle("traceEventRenderer.copy")[0]
      const lastCopyTimer = () => {
        const index = timeoutSpy.mock.calls.findLastIndex(([, delay]) => delay === 2000)
        expect(index).toBeGreaterThanOrEqual(0)
        return { handle: timeoutSpy.mock.results[index].value, callback: timeoutSpy.mock.calls[index][0] as () => void }
      }

      // The copied state follows the awaited clipboard write, so flush it.
      await act(async () => { fireEvent.click(button) })
      const firstTimer = lastCopyTimer()
      expect(button.querySelector("svg.text-green-500")).not.toBeNull()
      await act(async () => { fireEvent.click(button) })
      const secondTimer = lastCopyTimer()
      expect(secondTimer.handle).not.toBe(firstTimer.handle)
      expect(clearSpy).toHaveBeenCalledWith(firstTimer.handle)
      expect(clipboardWriteTextMock).toHaveBeenCalledTimes(2)
      expect(button.querySelector("svg.text-green-500")).not.toBeNull()

      if (finish === "expire") {
        // Invoke the captured two-second callback without wall-clock sleeps or
        // fake timers that would also affect Framer Motion's shared scheduler.
        clearTimeout(secondTimer.handle)
        clearSpy.mockClear()
        act(() => secondTimer.callback())
        expect(button.querySelector("svg.text-green-500")).toBeNull()
        unmount()
        expect(clearSpy).not.toHaveBeenCalledWith(secondTimer.handle)
      } else {
        unmount()
        expect(clearSpy).toHaveBeenCalledWith(secondTimer.handle)
      }
    } finally {
      cleanup()
    }
  })

  it("renders image artifacts inline from tool results", async () => {
    apiRequestMock.mockResolvedValue({
      ok: true,
      blob: async () => new Blob(["image-bytes"], { type: "image/png" }),
    })

    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { step_name: "Generate image", description: "Generate image" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { tool_name: "generate_image", tool_args: { prompt: "test" } },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "step-1",
            timestamp: Date.now(),
            data: {
              result: {
                success: true,
                artifacts: [
                  {
                    type: "image",
                    file_id: "582e7b79-4de9-4905-b73b-7d5a70ad64fe",
                    filename: "generated_image.png",
                    display: "inline",
                  },
                ],
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(
      screen.getByRole("button", {
        name: /traceEventRenderer.executeTool:Generate Image/,
      }),
    )

    const image = await screen.findByAltText("generated_image.png")
    await waitFor(() => {
      expect(image.getAttribute("src")).toMatch(/^blob:/)
    })
    expect(apiRequestMock).toHaveBeenCalledWith(
      "http://api.local/api/files/preview/582e7b79-4de9-4905-b73b-7d5a70ad64fe",
      expect.objectContaining({ cache: "no-cache" }),
    )
  })

  it("renders trace file artifacts and markdown as inert text when files are disabled", () => {
    appContextMock.filesDisabled = true

    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-disabled",
            timestamp: Date.now(),
            data: {
              step_name: "Create disabled artifact",
              description: "Create disabled artifact",
            },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "step-disabled",
            timestamp: Date.now() + 1,
            data: {
              tool_name: "document_tool",
              tool_args: {},
            },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "step-disabled",
            timestamp: Date.now() + 2,
            data: {
              result: {
                success: true,
                output: "[trace report.docx](file:trace-output-id)",
                artifacts: [
                  {
                    type: "document",
                    file_id: "trace-artifact-id",
                    filename: "artifact.docx",
                    display: "inline",
                  },
                  {
                    type: "image",
                    preview_url: "https://files.example/secret-preview",
                    display: "inline",
                  },
                ],
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(
      screen.getByRole("button", {
        name: /traceEventRenderer.executeTool:Document Tool/,
      }),
    )

    expect(screen.getByText("artifact.docx")).not.toHaveAttribute("href")
    expect(screen.getByText("image")).not.toHaveAttribute("href")
    expect(screen.getByText("trace report.docx")).not.toHaveAttribute("href")
    expect(document.body.innerHTML).not.toContain(
      "https://files.example/secret-preview",
    )
    expect(screen.queryByTestId("docx-preview")).not.toBeInTheDocument()
    expect(apiRequestMock).not.toHaveBeenCalled()

    fireEvent.click(screen.getByText("artifact.docx"))
    fireEvent.click(screen.getByText("trace report.docx"))
    expect(appContextMock.openFilePreview).not.toHaveBeenCalled()
    expect(appContextMock.dispatch).not.toHaveBeenCalledWith(
      expect.objectContaining({ type: "SET_FILE_PREVIEW_CONTENT" }),
    )
  })

  it("uses the files-disabled representation for trace object DOM and copies", () => {
    appContextMock.filesDisabled = true

    const output = {
      artifacts: [{
        fileId: "trace-output-id",
        path: "/private/trace-output.pdf",
        previewUrl: "https://files.example/preview/trace-output",
        signed_url: "https://files.example/signed/trace-output",
        url: "https://files.example/generic-trace-output-url",
        fileName: "trace-output.pdf",
        type: "application/pdf",
        text: "[open trace output](file:trace-output-id)",
      }],
      message: "Open (/private/tenant/secret.txt) with path=/private/tenant/config.json and output/report.pdf",
      summary: "Summary /private/tenant/summary.txt",
      detail: "Detail /tmp/tenant/detail.txt",
      note: "Note /workspace/tenant/note.txt",
      stdout: "stdout: /sandbox/tenant/stdout.log",
      stderr: "stderr: /data/tenant/stderr.log",
      runtimePaths: "Runtime /app/src, /opt/xagent, /var/tmp, /srv/app, and /etc/passwd",
      routes: "Keep /v1/openapi.json and /care/export.csv",
      taskUrl: "https://api.example/tasks/42",
    }

    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "trace-safe-output",
            timestamp: Date.now(),
            data: { step_name: "Inspect output", description: "Inspect output" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "trace-safe-output",
            timestamp: Date.now() + 1,
            data: { tool_name: "inspect_output", tool_args: {} },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "trace-safe-output",
            timestamp: Date.now() + 2,
            data: { result: { success: true, output: output as unknown as string } },
          },
        ]}
      />,
    )

    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executeTool:Inspect Output/,
    }))

    expect(container).toHaveTextContent("trace-output.pdf")
    expect(container).toHaveTextContent("open trace output")
    expect(container).toHaveTextContent("Open (secret.txt) with path=config.json and report.pdf")
    expect(container).toHaveTextContent("Summary summary.txt")
    expect(container).toHaveTextContent("Detail detail.txt")
    expect(container).toHaveTextContent("Note note.txt")
    expect(container).toHaveTextContent("stdout: stdout.log")
    expect(container).toHaveTextContent("stderr: stderr.log")
    expect(container).toHaveTextContent("Runtime src, xagent, tmp, app, and passwd")
    expect(container).toHaveTextContent("Keep /v1/openapi.json and /care/export.csv")
    expect(container).toHaveTextContent("https://api.example/tasks/42")
    expect(container.innerHTML).not.toContain("trace-output-id")
    expect(container.innerHTML).not.toContain("/private/trace-output.pdf")
    expect(container.innerHTML).not.toContain("https://files.example/preview/trace-output")
    expect(container.innerHTML).not.toContain("https://files.example/signed/trace-output")
    expect(container.innerHTML).not.toContain("https://files.example/generic-trace-output-url")
    expect(container.innerHTML).not.toContain("/private/tenant/secret.txt")
    expect(container.innerHTML).not.toContain("/private/tenant/config.json")
    expect(container.innerHTML).not.toContain("output/report.pdf")
    expect(container.innerHTML).not.toContain("/app/src")
    expect(container.innerHTML).not.toContain("/opt/xagent")
    expect(container.innerHTML).not.toContain("/var/tmp")
    expect(container.innerHTML).not.toContain("/srv/app")
    expect(container.innerHTML).not.toContain("/etc/passwd")

    const copyButtons = screen.getAllByTitle("traceEventRenderer.copy")
    fireEvent.click(copyButtons[copyButtons.length - 1])

    const copied = clipboardWriteTextMock.mock.calls.at(-1)?.[0]
    expect(copied).not.toContain("trace-output-id")
    expect(copied).not.toContain("/private/trace-output.pdf")
    expect(copied).not.toContain("https://files.example/preview/trace-output")
    expect(copied).not.toContain("https://files.example/signed/trace-output")
    expect(copied).not.toContain("https://files.example/generic-trace-output-url")
    expect(copied).not.toContain("/private/tenant/secret.txt")
    expect(copied).not.toContain("/private/tenant/config.json")
    expect(copied).not.toContain("output/report.pdf")
    expect(copied).not.toContain("/app/src")
    expect(copied).not.toContain("/opt/xagent")
    expect(copied).not.toContain("/var/tmp")
    expect(copied).not.toContain("/srv/app")
    expect(copied).not.toContain("/etc/passwd")
    expect(JSON.parse(copied)).toEqual({
      artifacts: [{
        fileName: "trace-output.pdf",
        type: "application/pdf",
        text: "open trace output",
      }],
      message: "Open (secret.txt) with path=config.json and report.pdf",
      summary: "Summary summary.txt",
      detail: "Detail detail.txt",
      note: "Note note.txt",
      stdout: "stdout: stdout.log",
      stderr: "stderr: stderr.log",
      runtimePaths: "Runtime src, xagent, tmp, app, and passwd",
      routes: "Keep /v1/openapi.json and /care/export.csv",
      taskUrl: "https://api.example/tasks/42",
    })
  })

  it("terminates cyclic tool output at the renderer boundary without exposing local paths", () => {
    appContextMock.filesDisabled = true
    const output: Record<string, unknown> = {
      label: "cyclic output",
      file_path: "/private/tenant/cyclic-secret.txt",
    }
    output.self = output

    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "cyclic-output",
            timestamp: Date.now(),
            data: { step_name: "Inspect cyclic output", description: "Inspect cyclic output" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "cyclic-output",
            timestamp: Date.now() + 1,
            data: { tool_name: "inspect_cyclic", tool_args: {} },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "cyclic-output",
            timestamp: Date.now() + 2,
            data: { result: { success: true, output } },
          },
        ]}
      />,
    )

    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executeTool:Inspect Cyclic/,
    }))

    expect(container).toHaveTextContent("[Circular]")
    expect(container.innerHTML).not.toContain("/private/tenant/cyclic-secret.txt")
  })

  it("projects the complete tool result before selecting a files-disabled message", () => {
    appContextMock.filesDisabled = true

    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "pptx-safe-output",
            timestamp: Date.now(),
            data: { step_name: "Create presentation", description: "Create presentation" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "pptx-safe-output",
            timestamp: Date.now() + 1,
            data: { tool_name: "pptx_tool", tool_args: {} },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "pptx-safe-output",
            timestamp: Date.now() + 2,
            data: {
              result: {
                success: true,
                output_path: "/private/generated/deck.pptx",
                message: "Created PPTX file: /private/generated/deck.pptx",
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executeTool:Pptx Tool/,
    }))

    expect(container).toHaveTextContent("Created PPTX file: deck.pptx")
    expect(container.innerHTML).not.toContain("/private/generated/deck.pptx")

    const copyButtons = screen.getAllByTitle("traceEventRenderer.copy")
    fireEvent.click(copyButtons[copyButtons.length - 1])
    expect(clipboardWriteTextMock).toHaveBeenLastCalledWith(
      "Created PPTX file: deck.pptx",
    )
  })

  it("keeps the selected raw tool message when files are enabled", () => {
    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "pptx-legacy-output",
            timestamp: Date.now(),
            data: { step_name: "Create presentation", description: "Create presentation" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "pptx-legacy-output",
            timestamp: Date.now() + 1,
            data: { tool_name: "pptx_tool", tool_args: {} },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "pptx-legacy-output",
            timestamp: Date.now() + 2,
            data: {
              result: {
                success: true,
                output_path: "/private/generated/deck.pptx",
                message: "Created PPTX file: /private/generated/deck.pptx",
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executeTool:Pptx Tool/,
    }))

    expect(container).toHaveTextContent(
      "Created PPTX file: /private/generated/deck.pptx",
    )

    const copyButtons = screen.getAllByTitle("traceEventRenderer.copy")
    fireEvent.click(copyButtons[copyButtons.length - 1])
    expect(clipboardWriteTextMock).toHaveBeenLastCalledWith(
      "Created PPTX file: /private/generated/deck.pptx",
    )
  })

  it("removes prepared HTML asset identities and locations from DOM and copies", () => {
    appContextMock.filesDisabled = true

    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "prepared-asset-output",
            timestamp: Date.now(),
            data: { step_name: "Prepare asset", description: "Prepare asset" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "prepared-asset-output",
            timestamp: Date.now() + 1,
            data: { tool_name: "prepare_html_asset", tool_args: {} },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "prepared-asset-output",
            timestamp: Date.now() + 2,
            data: {
              result: {
                success: true,
                source_file_id: "source-file-id",
                asset_file_id: "asset-file-id",
                html_src: "assets/chart.png",
                file_id: "registered-file-id",
                filename: "chart.png",
                preview_url: "https://files.example/preview/registered-file-id",
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executeTool:Prepare Html Asset/,
    }))

    expect(container).toHaveTextContent("chart.png")
    expect(container.innerHTML).not.toContain("source-file-id")
    expect(container.innerHTML).not.toContain("asset-file-id")
    expect(container.innerHTML).not.toContain("registered-file-id")
    expect(container.innerHTML).not.toContain("assets/chart.png")
    expect(container.innerHTML).not.toContain("https://files.example/preview")

    const copyButtons = screen.getAllByTitle("traceEventRenderer.copy")
    fireEvent.click(copyButtons[copyButtons.length - 1])
    expect(JSON.parse(clipboardWriteTextMock.mock.calls.at(-1)?.[0])).toEqual({
      success: true,
      filename: "chart.png",
    })
  })

  it("does not expose file-tool paths in summaries or tool details when files are disabled", () => {
    appContextMock.filesDisabled = true

    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "python-start",
            event_type: "react_task_start",
            step_id: "python-path",
            timestamp: Date.now(),
            data: { step_name: "Run Python", description: "Run Python" },
          },
          {
            event_id: "python-tool",
            event_type: "tool_execution_start",
            step_id: "python-path",
            timestamp: Date.now() + 1,
            data: {
              tool_name: "python_executor",
              tool_args: {
                code: "print('safe python text')",
                file_path: "/private/python/report.py",
                filename: "report.py",
              },
            },
          },
          {
            event_id: "file-start",
            event_type: "react_task_start",
            step_id: "file-path",
            timestamp: Date.now() + 2,
            data: { step_name: "Write file", description: "Write file" },
          },
          {
            event_id: "file-tool",
            event_type: "tool_execution_start",
            step_id: "file-path",
            timestamp: Date.now() + 3,
            data: {
              tool_name: "file_writer",
              tool_args: {
                file_path: "/private/files/report.txt",
                path: "/private/files/alternate.txt",
                filename: "report.txt",
                text: "safe file text",
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executeTool:Python Executor/,
    }))
    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executeTool:File Writer/,
    }))

    expect(container).toHaveTextContent("report.py")
    expect(container).toHaveTextContent("report.txt")
    expect(container).toHaveTextContent("safe python text")
    expect(container).toHaveTextContent("safe file text")
    expect(container.innerHTML).not.toContain("/private/python/report.py")
    expect(container.innerHTML).not.toContain("/private/files/report.txt")
    expect(container.innerHTML).not.toContain("/private/files/alternate.txt")
  })

  it("projects whole specialized tool actions before rendering code, commands, queries, and file content", () => {
    appContextMock.filesDisabled = true
    const { container } = render(
      <TraceEventRenderer
        events={[
          { event_id: "python-step", event_type: "react_task_start", step_id: "python", timestamp: 1, data: { step_name: "Python", description: "Read /private/shared/report.txt" } },
          { event_id: "python-tool", event_type: "tool_execution_start", step_id: "python", timestamp: 2, data: { tool_name: "python_executor", tool_args: { file_path: "/private/shared/report.txt", filename: "report.txt", code: "open('/private/shared/report.txt')" } } },
          { event_id: "bash-step", event_type: "react_task_start", step_id: "bash", timestamp: 3, data: { step_name: "Bash", description: "Bash" } },
          { event_id: "bash-tool", event_type: "tool_execution_start", step_id: "bash", timestamp: 4, data: { tool_name: "bash", tool_args: { output_dir: "/private/shared", filename: "report.txt", command: "cat /private/shared/report.txt" } } },
          { event_id: "search-step", event_type: "react_task_start", step_id: "search", timestamp: 5, data: { step_name: "Search", description: "Search" } },
          { event_id: "search-tool", event_type: "tool_execution_start", step_id: "search", timestamp: 6, data: { tool_name: "web_search", tool_args: { source_path: "/private/shared", filename: "report.txt", query: "find /private/shared/report.txt" } } },
          { event_id: "file-step", event_type: "react_task_start", step_id: "file", timestamp: 7, data: { step_name: "File", description: "File" } },
          { event_id: "file-tool", event_type: "tool_execution_start", step_id: "file", timestamp: 8, data: { tool_name: "file_writer", tool_args: { file_path: "/private/shared/report.txt", filename: "report.txt", content: "write /private/shared/report.txt" } } },
        ]}
      />,
    )

    for (const button of screen.getAllByRole("button", { name: /traceEventRenderer.executeTool/ })) {
      fireEvent.click(button)
    }

    expect(container.innerHTML).not.toContain("/private/shared")
    expect(container).toHaveTextContent("report.txt")
  })

  it("uses the shared safe representation for reasoning and failure trace DOM", () => {
    appContextMock.filesDisabled = true

    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "llm-step",
            event_type: "react_task_start",
            step_id: "llm-safe-failure",
            timestamp: Date.now(),
            data: { step_name: "Reason safely", description: "Reason safely" },
          },
          {
            event_id: "llm-start",
            event_type: "llm_call_start",
            step_id: "llm-safe-failure",
            timestamp: Date.now() + 1,
            data: { model_name: "test-model" },
          },
          {
            event_id: "llm-end",
            event_type: "llm_call_end",
            step_id: "llm-safe-failure",
            timestamp: Date.now() + 2,
            data: {
              response: {
                reasoning: "[reasoning report](file:reasoning-secret-id) from `/private/reasoning.txt`",
              },
            },
          },
          {
            event_id: "llm-failure-step",
            event_type: "react_task_start",
            step_id: "llm-error-safe-failure",
            timestamp: Date.now() + 3,
            data: { step_name: "LLM failure", description: "LLM failure" },
          },
          {
            event_id: "llm-failure-start",
            event_type: "llm_call_start",
            step_id: "llm-error-safe-failure",
            timestamp: Date.now() + 4,
            data: { model_name: "test-model" },
          },
          {
            event_id: "llm-failed",
            event_type: "llm_call_failed",
            step_id: "llm-error-safe-failure",
            timestamp: Date.now() + 5,
            data: {
              error: "[LLM failure report](file:llm-failure-secret-id)",
            },
          },
          {
            event_id: "tool-step",
            event_type: "react_task_start",
            step_id: "tool-safe-failure",
            timestamp: Date.now() + 6,
            data: { step_name: "Fail safely", description: "Fail safely" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "tool-safe-failure",
            timestamp: Date.now() + 7,
            data: { tool_name: "inspect_output", tool_args: {} },
          },
          {
            event_id: "tool-failed",
            event_type: "tool_execution_failed",
            step_id: "tool-safe-failure",
            timestamp: Date.now() + 8,
            data: {
              error: "[tool failure report](file:tool-failure-secret-id)",
            },
          },
          {
            event_id: "generic-step",
            event_type: "react_task_start",
            step_id: "generic-safe-failure",
            timestamp: Date.now() + 9,
            data: { step_name: "Generic failure", description: "Generic failure" },
          },
          {
            event_id: "generic-failed",
            event_type: "trace_error",
            step_id: "generic-safe-failure",
            timestamp: Date.now() + 10,
            data: {
              error: "[generic failure report](file:generic-failure-secret-id)",
            },
          },
        ]}
      />,
    )

    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executeTool:Inspect Output/,
    }))
    fireEvent.click(screen.getByRole("button", {
      name: /traceEventRenderer.executionFailed/,
    }))

    expect(container).toHaveTextContent("reasoning report")
    expect(container).toHaveTextContent("reasoning.txt")
    expect(container).toHaveTextContent("LLM failure report")
    expect(container).toHaveTextContent("tool failure report")
    expect(container).toHaveTextContent("generic failure report")
    expect(container.innerHTML).not.toContain("reasoning-secret-id")
    expect(container.innerHTML).not.toContain("/private/reasoning.txt")
    expect(container.innerHTML).not.toContain("llm-failure-secret-id")
    expect(container.innerHTML).not.toContain("tool-failure-secret-id")
    expect(container.innerHTML).not.toContain("generic-failure-secret-id")
  })

  it("renders pptx artifacts inline through PptxPreviewRenderer", async () => {
    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { step_name: "Create slides", description: "Create slides" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { tool_name: "pptx_tool", tool_args: { topic: "test" } },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "step-1",
            timestamp: Date.now(),
            data: {
              result: {
                success: true,
                artifacts: [
                  {
                    type: "presentation",
                    file_id: "slides-file-id",
                    filename: "report.pptx",
                    display: "inline",
                  },
                ],
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(
      screen.getByRole("button", {
        name: /traceEventRenderer.executeTool:Pptx Tool/,
      }),
    )

    // Managed fileId path: mount PptxPreviewRenderer immediately and let it
    // probe the PDF endpoint first instead of eagerly downloading raw bytes.
    expect(await screen.findByTestId("pptx-preview")).toHaveTextContent("slides-file-id")
    expect(apiRequestMock).not.toHaveBeenCalledWith(
      "http://api.local/api/files/public/preview/slides-file-id",
      expect.anything(),
    )
  })

  it("renders docx artifacts inline with the document renderer", async () => {
    apiRequestMock.mockResolvedValue({
      ok: true,
      arrayBuffer: async () => new Uint8Array([65, 66]).buffer,
    })

    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { step_name: "Create doc", description: "Create doc" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { tool_name: "document_tool", tool_args: {} },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "step-1",
            timestamp: Date.now(),
            data: {
              result: {
                success: true,
                artifacts: [
                  {
                    type: "document",
                    file_id: "doc-file-id",
                    filename: "summary.docx",
                    display: "inline",
                  },
                ],
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(
      screen.getByRole("button", {
        name: /traceEventRenderer.executeTool:Document Tool/,
      }),
    )

    expect(await screen.findByTestId("docx-preview")).toHaveTextContent("QUI=")
    expect(apiRequestMock).toHaveBeenCalledWith(
      "http://api.local/api/files/public/preview/doc-file-id",
      expect.objectContaining({ cache: "no-cache" }),
    )
  })

  it("renders xlsx artifacts inline with the spreadsheet renderer", async () => {
    apiRequestMock.mockResolvedValue({
      ok: true,
      arrayBuffer: async () => new Uint8Array([88, 89]).buffer,
    })

    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { step_name: "Create workbook", description: "Create workbook" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { tool_name: "excel", tool_args: {} },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "step-1",
            timestamp: Date.now(),
            data: {
              result: {
                success: true,
                artifacts: [
                  {
                    type: "spreadsheet",
                    file_id: "sheet-file-id",
                    filename: "data.xlsx",
                    display: "inline",
                  },
                ],
              },
            },
          },
        ]}
      />,
    )

    fireEvent.click(
      screen.getByRole("button", {
        name: /traceEventRenderer.executeTool:Excel/,
      }),
    )

    expect(await screen.findByTestId("excel-preview")).toHaveTextContent("WFk=")
  })

  it("renders assistant content on the tool call details", () => {
    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { step_name: "Search", description: "Search" },
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: {
              tool_name: "web_search",
              tool_params: { query: "ai news" },
              assistant_content: "I need current search results first.",
            },
          },
        ]}
      />,
    )

    expect(screen.getByText("I need current search results first.")).toBeInTheDocument()
    expect(screen.queryByText("traceEventRenderer.toolCallNote")).not.toBeInTheDocument()
  })

  it("interleaves agent progress into the active thinking process", () => {
    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: 1000,
            data: {},
          },
          {
            event_id: "first-tool",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: 2000,
            data: { tool_name: "first_tool", tool_params: { query: "first" } },
          },
          {
            event_id: "second-tool",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: 4000,
            data: { tool_name: "second_tool", tool_params: { query: "second" } },
          },
          {
            event_id: "end",
            event_type: "react_task_end",
            step_id: "step-1",
            timestamp: 5000,
            data: {},
          },
          {
            event_id: "progress",
            event_type: "agent_progress",
            step_id: "step-1",
            timestamp: 3000,
            data: {
              message: "Still searching the remaining sources.",
              message_type: "progress",
            },
          },
          {
            event_id: "legacy-progress",
            event_type: "agent_message",
            timestamp: 3500,
            data: {
              message: "Legacy progress also stays in the process.",
              message_type: "progress",
              expect_response: false,
            },
          },
        ]}
      />,
    )

    const stepToggles = screen.getAllByRole("button", {
      name: /traceEventRenderer\.(thoughtProcess|taskExecution)/,
    })
    expect(stepToggles).toHaveLength(1)

    fireEvent.click(stepToggles[0])

    expect(screen.getByText("Legacy progress also stays in the process.")).toBeInTheDocument()
    expect(screen.getByText("Still searching the remaining sources.")).toBeInTheDocument()
    expect(screen.queryByText("traceEventRenderer.progressMessage")).not.toBeInTheDocument()

    const renderedText = document.body.textContent || ""
    expect(renderedText.indexOf("traceEventRenderer.executeTool:First Tool")).toBeLessThan(
      renderedText.indexOf("Still searching the remaining sources."),
    )
    expect(renderedText.indexOf("Legacy progress also stays in the process.")).toBeLessThan(
      renderedText.indexOf("traceEventRenderer.executeTool:Second Tool"),
    )
  })

  it("keeps trace event ordering stable when timestamps are invalid", () => {
    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: -1,
            data: {},
          },
          {
            event_id: "invalid-start",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: "not-a-date" as unknown as number,
            data: { tool_name: "invalid_time_tool", tool_params: { query: "invalid" } },
          },
          {
            event_id: "also-invalid-start",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: undefined as unknown as number,
            data: { tool_name: "missing_time_tool", tool_params: { query: "missing" } },
          },
        ]}
      />,
    )

    const renderedText = document.body.textContent || ""
    expect(renderedText.indexOf("traceEventRenderer.executeTool:Invalid Time Tool")).toBeLessThan(
      renderedText.indexOf("traceEventRenderer.executeTool:Missing Time Tool"),
    )
  })

  it("collapses completed thinking process and keeps it visibly expandable", () => {
    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: {},
          },
          {
            event_id: "tool-start",
            event_type: "tool_execution_start",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { tool_name: "web_search", tool_params: { query: "ai news" } },
          },
          {
            event_id: "tool-end",
            event_type: "tool_execution_end",
            step_id: "step-1",
            timestamp: Date.now(),
            data: { result: { success: true, output: "done" } },
          },
          {
            event_id: "end",
            event_type: "react_task_end",
            step_id: "step-1",
            timestamp: Date.now(),
            data: {},
          },
        ]}
      />,
    )

    const toggle = screen.getByRole("button", {
      name: /traceEventRenderer.thoughtProcess/,
    })

    expect(toggle).toHaveAttribute("aria-expanded", "false")
    expect(screen.getByText("traceEventRenderer.showProcess")).toBeInTheDocument()
    expect(screen.queryByText(/traceEventRenderer.executeTool:Web Search/)).not.toBeInTheDocument()

    fireEvent.click(toggle)

    expect(toggle).toHaveAttribute("aria-expanded", "true")
    expect(screen.getByText("traceEventRenderer.hideProcess")).toBeInTheDocument()
    expect(screen.getByText(/traceEventRenderer.executeTool:Web Search/)).toBeInTheDocument()
  })

  it("shows the execution plan action only in a process with DAG execution events", () => {
    const onOpenExecutionPlan = vi.fn()
    const { rerender } = render(
      <TraceEventRenderer
        onOpenExecutionPlan={onOpenExecutionPlan}
        events={[
          {
            event_id: "react-start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: 1000,
            data: {},
          },
        ]}
      />,
    )

    expect(screen.queryByTitle("chatPage.executionPlan.tooltip")).not.toBeInTheDocument()

    rerender(
      <TraceEventRenderer
        onOpenExecutionPlan={onOpenExecutionPlan}
        events={[
          {
            event_id: "dag-execution",
            event_type: "dag_execution",
            timestamp: 1000,
            data: {
              phase: "executing",
              steps: [{ id: "1", task: "Create audio", dependencies: [] }],
            },
          },
        ]}
      />,
    )

    fireEvent.click(screen.getByText("chatPage.executionPlan.dagSectionOne:1"))
    expect(onOpenExecutionPlan).toHaveBeenCalledOnce()

    rerender(
      <TraceEventRenderer
        onOpenExecutionPlan={onOpenExecutionPlan}
        events={[
          {
            event_id: "dag-execution",
            event_type: "dag_execution",
            timestamp: 1000,
            data: {
              phase: "executing",
              steps: [
                { id: "1", task: "Create audio", dependencies: [] },
                { id: "2", task: "Edit audio", dependencies: ["1"] },
              ],
            },
          },
        ]}
      />,
    )

    expect(screen.getByText("chatPage.executionPlan.dagSectionOther:2")).toBeInTheDocument()
  })

  it("stops running process spinners when the parent task has failed", () => {
    const { container } = render(
      <TraceEventRenderer
        taskStatus="failed"
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: 1000,
            data: {},
          },
          {
            event_id: "llm-start",
            event_type: "llm_call_start",
            step_id: "step-1",
            timestamp: 2000,
            data: { model_name: "gpt-test" },
          },
          {
            event_id: "llm-failed",
            event_type: "llm_call_failed",
            step_id: "step-1",
            timestamp: 3000,
            data: { error: "OpenAI bad request" },
          },
        ]}
      />,
    )

    expect(container.querySelector(".animate-spin")).toBeNull()
  })

  it("infers a failed process from terminal trace errors when task status is unavailable", () => {
    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "step-1",
            timestamp: 1000,
            data: {},
          },
          {
            event_id: "llm-start",
            event_type: "llm_call_start",
            step_id: "step-1",
            timestamp: 2000,
            data: { model_name: "gpt-test" },
          },
          {
            event_id: "trace-error",
            event_type: "trace_error",
            step_id: "step-1",
            timestamp: 3000,
            data: {
              error_type: "agent_error",
              status: "failed",
              error_message: "All patterns failed",
            },
          },
        ]}
      />,
    )

    expect(container.querySelector(".animate-spin")).toBeNull()
  })

  it("stops spinning when a step-local trace error has no explicit status", () => {
    const { container } = render(
      <TraceEventRenderer
        events={[
          {
            event_id: "start",
            event_type: "react_task_start",
            step_id: "react-step",
            timestamp: 1000,
            data: {},
          },
          {
            event_id: "llm-start",
            event_type: "llm_call_start",
            step_id: "react-step",
            timestamp: 2000,
            data: { model_name: "gpt-test" },
          },
          {
            event_id: "trace-error",
            event_type: "trace_error",
            step_id: "react-step",
            timestamp: 3000,
            data: {
              error_type: "agent_pattern_error",
              error_message: "OpenAI bad request",
            },
          },
        ]}
      />,
    )

    expect(container.querySelector(".animate-spin")).toBeNull()
    expect(container).toHaveTextContent("OpenAI bad request")
  })

  it("renders workforce delegation trace events as a dedicated step", () => {
    const onAgentExecutionClick = vi.fn()
    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "delegation-start",
            event_type: "workforce_delegation_start",
            timestamp: Date.now(),
            data: {
              workforce_run_id: 5,
              worker_member_id: 7,
              worker_task_id: 99,
              worker_alias: "Researcher",
              tool_name: "research_worker",
            },
          },
          {
            event_id: "delegation-end",
            event_type: "workforce_delegation_end",
            timestamp: Date.now(),
            data: {
              worker_task_id: 99,
              output: "Research complete",
            },
          },
        ]}
        onAgentExecutionClick={onAgentExecutionClick}
      />,
    )

    fireEvent.click(screen.getByRole("button", {
      name: "traceEventRenderer.viewAgentExecution",
    }))
    expect(onAgentExecutionClick).toHaveBeenCalledWith(expect.objectContaining({
      workerTaskId: "99",
      agentName: "Researcher",
      workerAlias: "Researcher",
      status: "completed",
    }))

    expect(screen.getByRole("heading", {
      name: /traceEventRenderer.delegateToWorker:Researcher/,
    })).toBeInTheDocument()
    expect(screen.queryByRole("button", {
      name: "traceEventRenderer.showProcess",
    })).not.toBeInTheDocument()
    expect(screen.queryByText(/Research complete/)).not.toBeInTheDocument()
  })

  it("renders each workforce manager summary after its completed Agent call", () => {
    render(
      <TraceEventRenderer
        onAgentExecutionClick={vi.fn()}
        events={[
          {
            event_id: "manager-start",
            event_type: "react_task_start",
            step_id: "manager-react",
            timestamp: 1000,
            data: {},
          },
          {
            event_id: "research-start",
            event_type: "workforce_delegation_start",
            timestamp: 2000,
            data: {
              worker_task_id: "agent_research_run",
              worker_alias: "Researcher",
            },
          },
          {
            event_id: "research-end",
            event_type: "workforce_delegation_end",
            timestamp: 3000,
            data: {
              worker_task_id: "agent_research_run",
              output: '{"status":"complete"}',
            },
          },
          {
            event_id: "research-summary",
            event_type: "agent_progress",
            step_id: "manager-react",
            timestamp: 4000,
            data: {
              message: "## Research Complete\n\nThe evidence is ready for script writing.",
            },
          },
          {
            event_id: "writer-start",
            event_type: "workforce_delegation_start",
            timestamp: 5000,
            data: {
              worker_task_id: "agent_writer_run",
              worker_alias: "Writer",
            },
          },
        ]}
      />,
    )

    expect(screen.getByRole("heading", {
      name: /traceEventRenderer.delegateToWorker:Researcher/,
    })).toBeInTheDocument()
    expect(screen.getByText("Research Complete")).toBeInTheDocument()
    expect(screen.getByText("The evidence is ready for script writing.")).toBeInTheDocument()

    const pageText = document.body.textContent || ""
    expect(pageText.indexOf("traceEventRenderer.delegateToWorker:Researcher"))
      .toBeLessThan(pageText.indexOf("Research Complete"))
    expect(pageText.indexOf("Research Complete"))
      .toBeLessThan(pageText.indexOf("traceEventRenderer.delegateToWorker:Writer"))
  })

  it("can render completed Agent details expanded by default", () => {
    render(
      <TraceEventRenderer
        defaultExpandSteps
        events={[
          {
            event_id: "worker-start",
            event_type: "react_task_start",
            step_id: "react-worker",
            timestamp: Date.now(),
            data: {
              source: "xagent-agent-tool-child",
              worker_task_id: "agent_17_d8306189",
              agent_name: "Video Generation Agent",
            },
          },
          {
            event_id: "worker-end",
            event_type: "react_task_end",
            step_id: "react-worker",
            timestamp: Date.now() + 1,
            data: {
              source: "xagent-agent-tool-child",
              worker_task_id: "agent_17_d8306189",
              agent_name: "Video Generation Agent",
              result: "Pilot scenes generated",
            },
          },
        ]}
        taskStatus="completed"
      />,
    )

    expect(screen.getByRole("button", { name: "Video Generation Agent" })).toHaveAttribute(
      "aria-expanded",
      "true",
    )
    expect(screen.queryByRole("button", {
      name: "traceEventRenderer.hideProcess",
    })).not.toBeInTheDocument()
  })

  it("groups delegated agent internals into the worker execution step", () => {
    const timestamp = Date.now()
    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "delegation-start",
            event_type: "workforce_delegation_start",
            timestamp,
            data: {
              worker_task_id: "agent_17_run",
              worker_alias: "Video Generation Agent",
              tool_name: "agent_17",
            },
          },
          {
            event_id: "child-react-start",
            event_type: "react_task_start",
            step_id: "react-child",
            timestamp: timestamp + 1,
            data: {
              source: "xagent-agent-tool-child",
              worker_task_id: "agent_17_run",
              agent_name: "Video Generation Agent",
            },
          },
          {
            event_id: "child-tool-start",
            event_type: "tool_execution_start",
            step_id: "react-child",
            timestamp: timestamp + 2,
            data: {
              source: "xagent-agent-tool-child",
              worker_task_id: "agent_17_run",
              agent_name: "Video Generation Agent",
              tool_name: "generate_video",
              tool_call_id: "video-call-1",
              tool_params: { seconds: "4" },
            },
          },
          {
            event_id: "child-tool-failed",
            event_type: "tool_execution_failed",
            step_id: "react-child",
            timestamp: timestamp + 3,
            data: {
              source: "xagent-agent-tool-child",
              worker_task_id: "agent_17_run",
              agent_name: "Video Generation Agent",
              tool_name: "generate_video",
              tool_call_id: "video-call-1",
              error: "Invalid duration",
            },
          },
        ]}
      />,
    )

    const workerToggle = screen
      .getAllByRole("button", { name: /Video Generation Agent/ })
      .find((button) => button.hasAttribute("aria-expanded"))
    expect(workerToggle).toBeDefined()
    if (workerToggle?.getAttribute("aria-expanded") === "false") {
      fireEvent.click(workerToggle)
    }

    const toolToggle = screen.getByRole("button", { name: /Generate Video/ })
    fireEvent.click(toolToggle)
    expect(screen.getByText("Invalid duration")).toBeInTheDocument()
  })

  const renderUnavailableConnector = (result: Record<string, unknown>) => render(
    <TraceEventRenderer
      events={[
        {
          event_id: "start",
          event_type: "react_task_start",
          step_id: "step-1",
          timestamp: 1,
          data: { step_name: "Work" },
        },
        {
          event_id: "tool-start",
          event_type: "tool_execution_start",
          step_id: "step-1",
          timestamp: 2,
          data: { tool_name: "mcp_google_drive_42_unavailable", tool_call_id: "A" },
        },
        {
          event_id: "tool-failed",
          event_type: "tool_execution_failed",
          step_id: "step-1",
          timestamp: 3,
          data: {
            tool_name: "mcp_google_drive_42_unavailable",
            tool_call_id: "A",
            error: "MCP server tools could not be loaded.",
            result,
          },
        },
      ]}
    />,
  )

  it("renders an unavailable connector call as a plain status line", () => {
    renderUnavailableConnector({ unavailable_server: "Google Drive" })

    const title = screen.getByText("traceEventRenderer.connectorUnavailable:Google Drive")
    expect(title.parentElement?.textContent).toBe(
      "traceEventRenderer.connectorUnavailable:Google Drive",
    )
    expect(screen.queryByRole("button", { name: /connectorUnavailable/ })).toBeNull()
    expect(screen.queryByRole("button", { name: /Unavailable/ })).toBeNull()
  })

  it("shows the credential error of an oauth_token_required outage on the status line", () => {
    renderUnavailableConnector({
      success: false,
      status: "error",
      error: "MCP server credentials are unavailable.",
      failure_code: "oauth_token_required",
      reason: "oauth_token_required",
      content: [{ text: "MCP server credentials are unavailable. Please reconnect the MCP server credentials and retry." }],
      is_error: true,
      unavailable_server: "Google Drive",
    })

    const title = screen.getByText("traceEventRenderer.connectorUnavailable:Google Drive")
    expect(title.parentElement).toHaveTextContent("MCP server credentials are unavailable.")
    expect(screen.queryByRole("button", { name: /Unavailable/ })).toBeNull()
  })

  it("renders workforce delegation failures as errors", () => {
    render(
      <TraceEventRenderer
        events={[
          {
            event_id: "delegation-start",
            event_type: "workforce_delegation_start",
            timestamp: Date.now(),
            data: {
              worker_task_id: 99,
              worker_alias: "Researcher",
            },
          },
          {
            event_id: "delegation-error",
            event_type: "workforce_delegation_error",
            timestamp: Date.now(),
            data: {
              worker_task_id: 99,
              error: "Worker timed out",
            },
          },
        ]}
      />,
    )

    expect(screen.getByRole("button", {
      name: /traceEventRenderer.delegateToWorker:Researcher/,
    })).toBeInTheDocument()

    const errorToggle = screen.getByRole("button", {
      name: /traceEventRenderer.workerFailed/,
    })
    fireEvent.click(errorToggle)

    expect(screen.getByText("Worker timed out")).toBeInTheDocument()
  })
})