Skip to content

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

80.0 KB
Raw Blame
import React, { useState, useRef, useEffect, useCallback, useMemo } from 'react';
import { useRouter } from 'next/navigation';
import { motion, AnimatePresence } from 'framer-motion';
import {
  CheckCircle2,
  Loader2,
  ChevronRight,
  ChevronDown,
  Wrench,
  Cpu,
  Info,
  Copy,
  Search,
  FileText,
  GitMerge,
  Check,
  Shield,
  MessageSquare,
  CircleSlash,
} from 'lucide-react';
import { cn } from '@/lib/utils';
import { useApp } from '@/contexts/app-context-chat';
import { useI18n, type Translate, type TranslateDynamic } from '@/contexts/i18n-context';
import { MarkdownRenderer } from "@/components/ui/markdown-renderer";
import {
  getFilesDisabledPresentationFileLabel,
  projectFilesDisabledPresentation,
  projectFilesDisabledToolResultPresentation,
  sanitizeFilesDisabledPresentationText,
  serializeFilesDisabledPresentation,
} from "@/lib/files-disabled-presentation";
import { ScrollArea } from "@/components/ui/scroll-area";
import { normalizeTimestampMs } from '@/lib/time-utils';
import { copyToClipboard } from '@/lib/clipboard';
import { toast } from '@/components/ui/sonner';
import { InlineFilePreview } from '@/components/file/inline-file-preview';
import {
  isStoppedTraceProcessStatus,
  resolveTraceProcessStatus,
} from '@/lib/trace-process-status';
import { getAgentTaskHref } from '@/lib/agent-ui-access';

// Types
interface ToolArgs {
  code?: string;
  file_path?: string;
  content?: string;
  [key: string]: unknown;
}

interface ToolArtifact {
  type?: string;
  file_id?: string;
  filename?: string;
  mime_type?: string;
  preview_url?: string;
  display?: string;
}

interface TraceEvent {
  event_id?: string;
  event_type?: string;
  action_type?: string;
  step_id?: string | null;
  timestamp?: number | string | null;
  data?: {
    action?: string;
    step_name?: string;
    description?: string;
    tool_names?: string[];
    model_name?: string;
    tool_name?: string;
    tool_args?: ToolArgs;
    tool_params?: ToolArgs;
    selected?: boolean;
    skill_name?: string;
    response?: {
      reasoning?: string;
      tool_name?: string;
      tool_args?: ToolArgs;
      tool_params?: ToolArgs;
      answer?: string;
      assistant_content?: string;
    };
    result?: unknown;
    tools?: Array<{
      function: {
        name: string;
        arguments?: string;
      };
    }>;
    success?: boolean;
    [key: string]: unknown;
  };
  tool_name?: string;
  result_type?: string;
}

function sanitizeTraceEvents(value: unknown): TraceEvent[] {
  if (!Array.isArray(value)) return [];
  return value.flatMap((candidate) => {
    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
      return [];
    }
    const source = candidate as Record<string, unknown>;
    const event = { ...source };
    const stringFields = [
      'event_id',
      'event_type',
      'action_type',
      'tool_name',
      'result_type',
    ];
    for (const field of stringFields) {
      if (field in event && typeof event[field] !== 'string') {
        delete event[field];
      }
    }
    if (
      'step_id' in event &&
      typeof event.step_id !== 'string' &&
      event.step_id !== null
    ) {
      delete event.step_id;
    }
    if (
      'timestamp' in event &&
      typeof event.timestamp !== 'number' &&
      typeof event.timestamp !== 'string' &&
      event.timestamp !== null
    ) {
      delete event.timestamp;
    }
    if (
      'data' in event &&
      (!event.data || typeof event.data !== 'object' || Array.isArray(event.data))
    ) {
      event.data = {};
    }
    return [event as TraceEvent];
  });
}

interface StepAction {
  id: string;
  type: 'llm' | 'tool' | 'info' | 'error';
  title: string;
  status: 'running' | 'completed' | 'failed' | 'interrupted';
  timestamp: number;
  data: {
    model?: string;
    tool?: string;
    args?: any;
    code?: string;
    output?: any;
    rawResult?: unknown;
    artifacts?: ToolArtifact[];
    reasoning?: string;
    assistant_content?: string;
    error?: any;
    tool_calls?: any;
    tool_call_id?: string;
    invocation_id?: string;
    sandboxed?: boolean;
    inline?: boolean;
    workforceSummary?: boolean;
    statusLine?: boolean;
  };
}

function formatActionContent(value: unknown, filesDisabled = false): string {
  if (value === undefined || value === null) {
    return '';
  }
  if (filesDisabled) {
    return serializeFilesDisabledPresentation(value)
  }
  if (typeof value === 'string') {
    return value;
  }
  try {
    return JSON.stringify(value, null, 2);
  } catch {
    return String(value);
  }
}

// Deliberately narrower than (and not the same union as) StepStatus in
// app-context-chat.tsx / ProgressPanel's ProgressStepView / center-panel.tsx's
// DAGNode.data: this status is derived locally from the trace event stream
// itself (dag_step_start/dag_step_end/etc.), not read off StepExecution, and
// mixes in whole-TASK states ("paused", "waiting_for_user") that the other
// three don't carry at the step level. A step only becomes "interrupted"
// through the process-level status in processTraceEvents' final settling
// pass. A per-step "interrupted" status is ignored: a react_task_end whose
// data.status is "interrupted" still marks its step "completed". No trace
// event distinguishes a step being "clarification_invalidated" from plain
// "running", so a step in that state renders here as "running" rather than
// reporting an unknown/wrong status.
interface ProcessedStep {
  stepId: string;
  stepName: string;
  description: string;
  status: 'pending' | 'running' | 'completed' | 'failed' | 'paused' | 'waiting_for_user' | 'interrupted';
  tools: Array<{ function: { name: string } }>;
  reasoning?: string;
  code: string;
  output: string;
  filePath?: string;
  actions: StepAction[];
  agentExecution?: AgentExecutionSummary;
}

interface TraceEventRendererProps {
  events: TraceEvent[];
  taskStatus?: string;
  onOpenExecutionPlan?: () => void;
  onAgentExecutionClick?: (execution: AgentExecutionSummary) => void;
  defaultExpandSteps?: boolean;
}

export interface AgentExecutionSummary {
  workerTaskId: string;
  agentId?: number;
  agentName: string;
  workerAlias?: string;
  status: 'running' | 'completed' | 'failed';
}

function isDagExecutionEvent(event: TraceEvent): boolean {
  const eventType = event.event_type || '';
  return eventType === 'dag_execution'
    || eventType === 'dag_execute_start'
    || eventType === 'dag_execute_end'
    || eventType === 'dag_plan_start'
    || eventType === 'dag_plan_end'
    || eventType.startsWith('dag_step_');
}

function getTraceData(event: TraceEvent): NonNullable<TraceEvent['data']> | undefined {
  if (event.data && typeof event.data === 'object' && !Array.isArray(event.data)) {
    return event.data;
  }
  if ('data' in event) {
    return undefined;
  }
  return event as unknown as NonNullable<TraceEvent['data']>;
}

const getWaitingQuestionFromEvents = (events: TraceEvent[]): string | null => {
  for (let i = events.length - 1; i >= 0; i--) {
    const event = events[i];
    if (event.event_type === 'agent_message') {
      const expectsResponse = event.data?.expect_response === true || event.data?.message_type === 'question';
      if (!expectsResponse) {
        continue;
      }
      const message = event.data?.message || event.data?.content;
      if (typeof message === 'string' && message.trim()) {
        return message;
      }
    }
    if (event.event_type === 'react_task_end') {
      const result = event.data?.result as any;
      if (
        result?.status === 'waiting_for_user' &&
        typeof result.message === 'string' &&
        result.message.trim()
      ) {
        return result.message;
      }
    }
  }
  return null;
};

// Raw tool identifiers (e.g. "python_executor") are internal names, not
// user-facing copy. Turn any unmapped one into readable words as a safety net
// so new/uncommon tools never fall back to a bare snake_case string.
function prettifyToolName(name: string): string {
  const spaced = name
    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
    .replace(/[_.-]+/g, ' ')
    .trim();
  // An all-separator name (rare, but possible for a malformed/adversarial
  // tool id) leaves nothing after stripping — an empty title is worse than
  // the raw name, so fall back to that instead of rendering blank.
  if (!spaced) return name;
  return spaced
    .split(' ')
    .filter(Boolean)
    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');
}

// The i18n toolNames table (i18n/locales/*.ts -> traceEventRenderer.toolNames)
// holds friendly phrasing ("Searching the web") for the common built-in
// tools; anything not listed there degrades to the prettified raw name
// instead of surfacing the identifier verbatim.
export function getFriendlyToolName(toolName: string, tDynamic?: TranslateDynamic): string {
  // toolName ultimately traces back to an external WS/API payload; the string
  // type is a compile-time annotation only; not a runtime guarantee. Guard
  // here too since this helper is exported and may be reused elsewhere.
  if (typeof toolName !== 'string' || !toolName) return '';
  const fallback = prettifyToolName(toolName);
  if (!tDynamic) return fallback;
  return tDynamic(`traceEventRenderer.toolNames.${toolName}`, fallback);
}

// Shared with ChatMessage.tsx's status line so both surfaces resolve the
// same event to the same raw tool name. Checks response.tool_name and
// data.tool_name independently rather than `a || b` then type-checking the
// combined result — the latter (this file's own previous version) gives up
// on an otherwise-valid data.tool_name if response.tool_name exists but
// happens to be a truthy non-string, e.g. {response: {tool_name: 42},
// tool_name: 'web_search'} resolved to '' instead of falling through.
export function getRawToolName(event: TraceEvent): string {
  const response = event.data?.response;
  if (response && typeof response.tool_name === 'string') {
    return response.tool_name;
  }
  return typeof event.data?.tool_name === 'string' ? event.data.tool_name : '';
}

export const isAgentProgressEvent = (event: TraceEvent): boolean => (
  event.event_type === 'agent_progress' ||
  (
    event.event_type === 'agent_message' &&
    event.data?.expect_response !== true &&
    event.data?.message_type !== 'question'
  )
);

// Shared with ChatMessage.tsx's status line so both surfaces agree on what
// counts as narration text for the same event — a hand-duplicated copy
// there previously used ?? instead of ||, silently disagreeing with this
// file on events shaped like {message: "", content: "..."}.
export function getProgressNarrationText(event: TraceEvent): string {
  const raw = event.data?.message || event.data?.content;
  return typeof raw === 'string' ? raw.trim() : '';
}

// Process trace events into steps
// Pure reducer over trace events -> ordered steps. Exported for unit testing
// (e.g. tool_call_id attribution under in-turn tool concurrency).
export function processTraceEvents(
  events: TraceEvent[],
  t: Translate,
  taskStatus?: string,
  tDynamic?: TranslateDynamic,
): ProcessedStep[] {
    const stepsMap = new Map<string, ProcessedStep>();
    // Steps that ever had more than one tool in flight at once. Their step-level
    // output scalar is meaningless (whichever tool finishes last would clobber
    // it), so once a step is flagged concurrent we stop writing step.output and
    // rely on the per-action outputs instead.
    const concurrentSteps = new Set<string>();
    let currentReactStepId: string | null = null;
    let lastCompletedWorkforceStepId: string | null = null;
    const orderedEvents = sanitizeTraceEvents(events)
      .map((event, index) => {
        const timestamp = normalizeTimestampMs(event.timestamp)
        return {
          event,
          index,
          timestamp: Number.isFinite(timestamp) ? timestamp : 0,
        }
      })
      .sort((a, b) => a.timestamp - b.timestamp || a.index - b.index);

    // Helper to find the last running action of a specific type
    const findLastRunningAction = (step: ProcessedStep, type: 'llm' | 'tool') => {
      for (let i = step.actions.length - 1; i >= 0; i--) {
        if (step.actions[i].type === type && step.actions[i].status === 'running') {
          return step.actions[i];
        }
      }
      return null;
    };

    // Match a running tool action by its tool_call_id. With concurrent tool
    // execution several same-named tools can be in flight at once, so pairing
    // by "last running tool" mis-attributes results; the id makes it exact.
    // Returns null when the id is absent so callers can fall back to
    // findLastRunningAction (legacy / single-tool events).
    const findRunningToolByCallId = (
      step: ProcessedStep,
      toolCallId?: string,
      invocationId?: string,
    ) => {
      if (!invocationId && !toolCallId) return null;
      for (let i = step.actions.length - 1; i >= 0; i--) {
        const action = step.actions[i];
        if (
          action.type === 'tool' &&
          action.status === 'running' &&
          (invocationId
            ? action.data?.invocation_id === invocationId
            : action.data?.tool_call_id === toolCallId)
        ) {
          return action;
        }
      }
      return null;
    };

    // A settlement lifecycle reopens a call whose pause pair already closed.
    // New traces identify that call by invocation id. Historical traces fall
    // back to the provider id and, only when necessary, the originating step.
    const findToolActionAcrossSteps = (
      toolCallId?: string,
      invocationId?: string,
      originStepId?: string,
    ) => {
      if (!invocationId && !toolCallId) return null;
      const matches: { stepId: string; action: StepAction }[] = [];
      for (const candidateStep of stepsMap.values()) {
        for (const action of candidateStep.actions) {
          if (
            action.type === 'tool' &&
            (invocationId
              ? action.data?.invocation_id === invocationId
              : action.data?.tool_call_id === toolCallId)
          ) {
            matches.push({ stepId: candidateStep.stepId, action });
          }
        }
      }
      if (matches.length === 0) return null;
      if (matches.length === 1) return matches[0].action;
      const exactStepMatches = matches.filter(({ stepId }) => stepId === originStepId);
      return exactStepMatches.length === 1 ? exactStepMatches[0].action : null;
    };

    // A settlement START records the target its terminal event must close.
    // Invocation ids are globally exact; the composite key is legacy-only.
    const settlementTargets = new Map<string, StepAction>();
    const settlementTargetKey = (
      toolCallId: string | undefined,
      invocationId?: string,
      originStepId?: string,
    ) => invocationId
      ? `invocation:${invocationId}`
      : `legacy:${toolCallId}::${originStepId ?? ''}`;
    const isSettlementEvent = (event: TraceEvent) =>
      event.data?.settlement_delivery === true;
    const resolveSettlementTarget = (
      toolCallId?: string,
      invocationId?: string,
      originStepId?: string,
    ) => {
      if (!invocationId && !toolCallId) return null;
      const key = settlementTargetKey(toolCallId, invocationId, originStepId);
      return settlementTargets.get(key)
        || findToolActionAcrossSteps(toolCallId, invocationId, originStepId);
    };

    orderedEvents.forEach(({ event, index, timestamp }) => {
      if (event.event_type?.startsWith('skill_select')) {
        return;
      }

      const eventData = getTraceData(event) || {};
      let stepId = event.step_id || (eventData.step_id as string) || 'default';
      const isProgressMessage = isAgentProgressEvent(event);
      const workerTaskId = typeof eventData.worker_task_id === 'string'
        || typeof eventData.worker_task_id === 'number'
        ? String(eventData.worker_task_id)
        : '';
      const isWorkforceDelegation = event.event_type?.startsWith('workforce_delegation_');
      const isDelegatedChildEvent =
        eventData.source === 'xagent-agent-tool-child' && Boolean(workerTaskId);
      const isWorkforceManagerSummary =
        isProgressMessage &&
        !isDelegatedChildEvent &&
        Boolean(lastCompletedWorkforceStepId);
      if (isWorkforceManagerSummary && lastCompletedWorkforceStepId) {
        stepId = lastCompletedWorkforceStepId;
      }
      if (isWorkforceDelegation || isDelegatedChildEvent) {
        stepId = String(
          workerTaskId ||
          `workforce-${eventData.workforce_run_id || 'run'}-${eventData.worker_member_id || eventData.agent_id || event.event_id || index}`
        );
      }

      if (event.event_type === 'react_task_start' || event.event_type === 'task_start_react') {
        currentReactStepId = stepId;
      }

      if ((event.event_type === 'react_task_end' || event.event_type === 'task_end_react' || event.event_type === 'task_completion' || event.event_type === 'react_task_failed' || event.event_type === 'task_failed_react') && stepId === 'default' && currentReactStepId) {
        stepId = currentReactStepId;
      }

      if (isProgressMessage && stepId === 'default' && currentReactStepId) {
        stepId = currentReactStepId;
      }

      if (!stepsMap.has(stepId)) {
        stepsMap.set(stepId, {
          stepId,
          stepName: '',
          description: '',
          status: 'pending',
          tools: [],
          reasoning: '',
          code: '',
          output: '',
          filePath: '',
          actions: [],
        });
      }

      const step = stepsMap.get(stepId)!;
      const eventId = event.event_id || `event-${index}`;

      if ((isWorkforceDelegation || isDelegatedChildEvent) && workerTaskId) {
        const previousExecution = step.agentExecution;
        const agentName = String(
          eventData.worker_alias ||
          eventData.agent_name ||
          eventData.tool_name ||
          previousExecution?.agentName ||
          t('traceEventRenderer.unknownWorker')
        );
        step.agentExecution = {
          workerTaskId,
          agentId: typeof eventData.agent_id === 'number' ? eventData.agent_id : previousExecution?.agentId,
          agentName,
          workerAlias: typeof eventData.worker_alias === 'string' ? eventData.worker_alias : previousExecution?.workerAlias,
          status: event.event_type === 'workforce_delegation_error'
            ? 'failed'
            : event.event_type === 'workforce_delegation_end'
              ? 'completed'
              : previousExecution?.status || 'running',
        };
      }

      // Process different event types
      if (event.event_type === 'dag_step_start' || event.event_type === 'react_task_start') {
        const delegatedAgentName = isDelegatedChildEvent && typeof eventData.agent_name === 'string'
          ? eventData.agent_name
          : '';
        step.stepName = delegatedAgentName
          || (eventData.step_name as string)
          || (event.event_type === 'react_task_start' ? t('traceEventRenderer.taskExecution') : '');
        step.description = (eventData.description as string) || (eventData.task as string) || '';
        step.status = 'running';

        const tools = eventData.tool_names || eventData.tools;
        if (tools && Array.isArray(tools)) {
          step.tools = tools.map((toolItem: any) => {
            if (typeof toolItem === 'string') return { function: { name: toolItem } };
            if (toolItem?.function?.name) return toolItem;
            return { function: { name: 'unknown' } };
          });
        }
      }

      if (event.event_type === 'llm_call_start') {
        step.actions.push({
          id: eventId,
          type: 'llm',
          title: t('traceEventRenderer.callLLM'),
          status: 'running',
          timestamp,
          data: { model: eventData.model_name }
        });
      }

      if (event.event_type === 'llm_call_end' || event.event_type === 'llm_call_result') {
        if (eventData.response?.reasoning) {
          step.reasoning = eventData.response.reasoning;
        }
        if (eventData.tools) {
          step.tools = eventData.tools;
        }

        const action = findLastRunningAction(step, 'llm');
        if (action) {
          action.status = 'completed';
          action.data.reasoning = eventData.response?.reasoning;
          action.data.tool_calls = eventData.tools;
        } else {
          // Fallback if no start event found
          step.actions.push({
            id: eventId,
            type: 'llm',
            title: t('traceEventRenderer.llmResponse'),
            status: 'completed',
            timestamp,
            data: {
              reasoning: eventData.response?.reasoning,
              tool_calls: eventData.tools
            }
          });
        }
      }

      if (isProgressMessage) {
        const message = getProgressNarrationText(event);
        if (message) {
          if (!step.stepName) {
            step.stepName = t('traceEventRenderer.taskExecution');
          }
          if (step.status === 'pending') {
            step.status = 'running';
          }
          step.actions.push({
            id: eventId,
            type: 'info',
            title: t('traceEventRenderer.progressMessage'),
            status: 'completed',
            timestamp,
            data: {
              output: message,
              inline: true,
              workforceSummary: isWorkforceManagerSummary,
            }
          });
        }
      }

      if (event.event_type === 'workforce_delegation_start') {
        lastCompletedWorkforceStepId = null;
        const workerName = String(
          eventData.worker_alias ||
          eventData.agent_name ||
          eventData.tool_name ||
          t('traceEventRenderer.unknownWorker')
        );
        step.stepName = t('traceEventRenderer.workforceDelegation');
        step.description = t('traceEventRenderer.delegateToWorker', { worker: workerName });
        step.status = 'running';
        step.actions.push({
          id: eventId,
          type: 'info',
          title: t('traceEventRenderer.delegateToWorker', { worker: workerName }),
          status: 'running',
          timestamp,
          data: {
            tool: eventData.tool_name,
            output: eventData,
          }
        });
      }

      if (event.event_type === 'workforce_delegation_end') {
        const output = eventData.output || eventData.response || '';
        step.stepName = step.stepName || t('traceEventRenderer.workforceDelegation');
        step.description = step.description || t('traceEventRenderer.workforceDelegation');
        step.status = 'completed';
        const action = step.actions.find((item) => item.type === 'info' && item.status === 'running');
        if (action) {
          action.status = 'completed';
          action.data.output = output || eventData;
        } else {
          step.actions.push({
            id: eventId,
            type: 'info',
            title: t('traceEventRenderer.workerReturned'),
            status: 'completed',
            timestamp,
            data: { output: output || eventData }
          });
        }
        lastCompletedWorkforceStepId = stepId;
      }

      if (event.event_type === 'workforce_delegation_error') {
        const errorMessage = eventData.error || eventData.message || t('traceEventRenderer.unknownError');
        step.stepName = step.stepName || t('traceEventRenderer.workforceDelegation');
        step.description = step.description || t('traceEventRenderer.workforceDelegation');
        step.status = 'failed';
        const action = step.actions.find((item) => item.type === 'info' && item.status === 'running');
        if (action) {
          action.type = 'error';
          action.title = t('traceEventRenderer.workerFailed');
          action.status = 'failed';
          action.data.output = undefined;
          action.data.error = errorMessage;
        } else {
          step.actions.push({
            id: eventId,
            type: 'error',
            title: t('traceEventRenderer.workerFailed'),
            status: 'failed',
            timestamp,
            data: { error: errorMessage }
          });
        }
        lastCompletedWorkforceStepId = stepId;
      }

      if (event.event_type === 'tool_execution_start') {
        // Support v1 tool_args and v2 tool_params shapes.
        const toolArgs =
          event.data?.response?.tool_args ||
          event.data?.response?.tool_params ||
          event.data?.tool_args ||
          event.data?.tool_params;
        if (toolArgs?.code) {
          step.code = toolArgs.code as string;
        }
        // Support file operations as well (file_path, content, etc.)
        if (toolArgs?.file_path && toolArgs?.content) {
          step.code = toolArgs.content as string;
        }
        // Capture file path if provided
        if (toolArgs?.file_path) {
          step.filePath = String(toolArgs.file_path);
        }
        const rawToolName = getRawToolName(event);
        const toolName = rawToolName || t('traceEventRenderer.unknownTool');
        const toolDisplayName = rawToolName ? getFriendlyToolName(rawToolName, tDynamic) : toolName;
        const toolCallId = event.data?.tool_call_id as string | undefined;
        const invocationId = event.data?.invocation_id as string | undefined;
        const assistantContent = event.data?.response?.assistant_content || event.data?.assistant_content;

        if (typeof assistantContent === 'string' && assistantContent.trim()) {
          step.actions.push({
            id: `${eventId}-assistant-content`,
            type: 'info',
            title: t('traceEventRenderer.toolCallNote'),
            status: 'completed',
            timestamp,
            data: {
              output: assistantContent.trim(),
              inline: true,
            }
          });
        }

        const settlementStartTarget = isSettlementEvent(event)
          ? resolveSettlementTarget(toolCallId, invocationId, event.step_id ?? undefined)
          : null;
        if (isSettlementEvent(event) && !settlementStartTarget && !step.stepName) {
          // A truncated history may omit the original task start. Keep the
          // terminal outcome in a visible, named fallback step.
          step.stepName = t('traceEventRenderer.taskExecution');
        }

        if (toolName && !settlementStartTarget) {
          // Merge with existing tools instead of replacing
          if (!step.tools.some(tItem => tItem.function.name === toolName)) {
            step.tools.push({ function: { name: toolName } });
          }
        }

        if (settlementStartTarget) {
          if (invocationId || toolCallId) {
            settlementTargets.set(
              settlementTargetKey(toolCallId, invocationId, event.step_id ?? undefined),
              settlementStartTarget,
            );
          }
        } else {
          const action: StepAction = {
            id: eventId,
            type: 'tool',
            title: t('traceEventRenderer.executeTool', { tool: toolDisplayName }),
            status: 'running',
            timestamp,
            data: {
              tool: toolName,
              args: toolArgs,
              code: step.code,
              tool_call_id: toolCallId,
              invocation_id: invocationId,
              sandboxed: !!event.data?.sandboxed
            }
          };
          step.actions.push(action);
          if (isSettlementEvent(event) && (invocationId || toolCallId)) {
            settlementTargets.set(
              settlementTargetKey(toolCallId, invocationId, event.step_id ?? undefined),
              action,
            );
          }
        }
      }

      if (event.event_type === 'tool_execution_end') {
        const result = event.data?.result;
        let output: any = '';
        if (result !== undefined) {
          if (typeof result === 'string') {
            output = result;
          } else if (typeof result === 'object' && result !== null) {
            if ('output' in result) {
              output = result.output;
            } else if ('message' in result) {
              output = result.message;
            } else {
              output = result; // fallback to the entire result object
            }
          } else {
            output = String(result);
          }
        } else if (event.data?.output !== undefined) {
          output = event.data.output;
        } else if (event.data?.response !== undefined) {
          output = event.data.response;
        } else if (event.data !== undefined) {
          // If no specific result/output field is found, maybe data itself has it or we can dump data
          // But only dump if we are sure there's some outcome. We'll leave it empty if we can't find anything,
          // except if there's an 'error' field handled elsewhere.
        }

        // Detect *actual* concurrency, not just multiple tools in the step: at
        // the moment a tool ends it is still marked 'running' (its status is set
        // below), so >1 running tool here means siblings overlapped it. Counting
        // total tool actions instead would wrongly suppress step.output for
        // tools that merely ran sequentially within the same step. Once a step
        // is concurrent the scalar is unreliable, so keep the per-action outputs
        // authoritative and stop writing step.output for it.
        const runningTools = step.actions.filter(
          a => a.type === 'tool' && a.status === 'running'
        );
        if (runningTools.length > 1) {
          concurrentSteps.add(stepId);
        }
        if (!concurrentSteps.has(stepId)) {
          step.output = output;
        }
        const artifacts =
          typeof result === 'object' &&
            result !== null &&
            'artifacts' in result &&
            Array.isArray(result.artifacts)
            ? result.artifacts
            : undefined;

        const endToolCallId = event.data?.tool_call_id as string | undefined;
        const endInvocationId = event.data?.invocation_id as string | undefined;
        const action = isSettlementEvent(event)
          ? resolveSettlementTarget(endToolCallId, endInvocationId, event.step_id ?? undefined)
          : findRunningToolByCallId(step, endToolCallId, endInvocationId) ||
            (!endInvocationId ? findLastRunningAction(step, 'tool') : null);
        if (isSettlementEvent(event) && !action && !step.stepName) {
          step.stepName = t('traceEventRenderer.taskExecution');
        }
        if (action) {
          action.status = 'completed';
          action.data.output = output;
          action.data.rawResult = result;
          if (artifacts) {
            action.data.artifacts = artifacts;
          }
        } else {
          // Fallback
          step.actions.push({
            id: eventId,
            type: 'tool',
            title: t('traceEventRenderer.toolExecutionFinished'),
            status: 'completed',
            timestamp,
            data: {
              output,
              rawResult: result,
              artifacts,
              sandboxed: !!event.data?.sandboxed
            }
          });
        }
      }

      // DAG steps emit the same end event for success and failure.
      const isFailedDagStepEnd = event.event_type === 'dag_step_end' && eventData.status === 'failed';
      const isFailedDagStep = isFailedDagStepEnd || event.event_type === 'dag_step_failed';
      if (!isFailedDagStepEnd && (event.event_type === 'dag_step_end' || event.event_type === 'step_completed' || event.event_type === 'react_task_end' || event.event_type === 'task_completion')) {
        step.status = 'completed';
        const shouldShowStepResult = event.event_type === 'dag_step_end' || event.event_type === 'step_completed';
        const result = shouldShowStepResult
          ? event.data?.result ?? event.data?.result_data ?? event.data?.response?.answer
          : undefined;
        const content = formatActionContent(result);
        if (shouldShowStepResult && content.trim()) {
          step.output = content;
          step.actions.push({
            id: `${eventId}-result`,
            type: 'info',
            title: t('traceEventRenderer.stepResult'),
            status: 'completed',
            timestamp,
            data: { output: content }
          });
        }
        // Ensure all actions are completed
        step.actions.forEach(a => {
          if (a.status === 'running') a.status = 'completed';
        });
      }

      if (isFailedDagStep || ['tool_execution_failed', 'llm_call_failed', 'react_task_failed', 'agent_error', 'trace_error'].includes(event.event_type as string)) {
        const isTerminalFailure =
          isFailedDagStep || ['react_task_failed', 'agent_error', 'trace_error'].includes(event.event_type as string);
        if (isTerminalFailure) {
          step.status = 'failed';
        } else if (step.status === 'pending') {
          step.status = 'running';
        }

        const unavailable = event.event_type === 'tool_execution_failed'
          ? (event.data?.result as { unavailable_server?: unknown; error?: unknown } | null | undefined)
          : undefined;
        const connector = unavailable?.unavailable_server;
        if (typeof connector === 'string' && connector.trim()) {
          const callId = event.data?.tool_call_id;
          const failedTool = getRawToolName(event);
          // Sibling calls may reuse an id, so the tool name must also match.
          const ownCards = step.actions.filter(
            a => a.type === 'tool' && a.status === 'running'
              && !!callId && a.data.tool_call_id === callId
              && a.data.tool === failedTool
          );
          const ownCard = ownCards.length === 1 ? ownCards[0] : null;
          const detail = unavailable?.error;
          const statusLine: StepAction = {
            id: ownCard?.id ?? eventId,
            type: 'info',
            title: t('traceEventRenderer.connectorUnavailable', { connector: connector.trim() }),
            status: 'completed',
            timestamp: ownCard?.timestamp ?? timestamp,
            data: typeof detail === 'string' && detail.trim()
              ? { statusLine: true, error: detail.trim() }
              : { statusLine: true },
          };
          if (ownCard) {
            step.actions[step.actions.indexOf(ownCard)] = statusLine;
          } else {
            step.actions.push(statusLine);
          }
          return;
        }

        // Extract error message with more fallback options
        const errorData = event.data || {};
        let errorMessage =
          errorData.error ||
          errorData.message ||
          errorData.error_message;

        if (!errorMessage && errorData.result) {
          errorMessage = (errorData.result as any).error || (errorData.result as any).message;
        }

        if (!errorMessage && typeof errorData === 'string') {
          errorMessage = errorData;
        }

        if (!errorMessage) {
          errorMessage = t('traceEventRenderer.unknownError');
        }

        // Try to find specific action type based on event type
        let runningAction = step.actions.find(a => a.status === 'running');

        // If no running action found, or type mismatch, try to find the last action of corresponding type
        if (event.event_type === 'tool_execution_failed') {
          const settlementTarget = isSettlementEvent(event)
            ? resolveSettlementTarget(
              errorData.tool_call_id as string | undefined,
              errorData.invocation_id as string | undefined,
              event.step_id ?? undefined,
            )
            : null;
          if (isSettlementEvent(event)) {
            runningAction = settlementTarget ?? undefined;
            if (settlementTarget) {
              settlementTarget.data.rawResult = event.data?.result;
              delete settlementTarget.data.output;
            } else if (!step.stepName) {
              step.stepName = t('traceEventRenderer.taskExecution');
            }
          } else {
            const lastTool =
              findRunningToolByCallId(
                step,
                errorData.tool_call_id as string | undefined,
                errorData.invocation_id as string | undefined,
              ) || (!errorData.invocation_id ? findLastRunningAction(step, 'tool') : null);
            if (lastTool) runningAction = lastTool;
          }
        } else if (event.event_type === 'llm_call_failed') {
          const lastLlm = findLastRunningAction(step, 'llm');
          if (lastLlm) runningAction = lastLlm;
        }

        if (runningAction) {
          runningAction.status = 'failed';
          runningAction.data.error = errorMessage;
        } else {
          step.actions.push({
            id: eventId,
            type: 'error',
            title: t('traceEventRenderer.executionFailed'),
            status: 'failed',
            timestamp,
            data: { error: errorMessage }
          });
        }
        if (isFailedDagStep) {
          // The step has stopped even if the task later delivers a partial answer.
          step.actions.forEach(action => {
            if (action.status === 'running') {
              action.status = 'failed';
              action.data.error = errorMessage;
            }
          });
        }
      }
    });

    const steps = Array.from(stepsMap.values()).filter(step => step.stepName);

    if (isStoppedTraceProcessStatus(taskStatus)) {
      steps.forEach((step) => {
        const runningActions = step.actions.filter(action => action.status === 'running');
        if (taskStatus === 'failed' && (step.status !== 'completed' || runningActions.length > 0)) {
          step.status = 'failed';
          runningActions.forEach((action) => {
            action.status = 'failed';
            action.data.error = action.data.error || t('traceEventRenderer.unknownError');
          });
          return;
        }

        if (taskStatus === 'completed' && step.status !== 'failed') {
          step.status = 'completed';
          runningActions.forEach((action) => {
            action.status = 'completed';
          });
          return;
        }

        if (
          (taskStatus === 'paused' || taskStatus === 'waiting_for_user') &&
          (step.status === 'pending' || step.status === 'running')
        ) {
          step.status = taskStatus;
          runningActions.forEach((action) => {
            action.status = 'completed';
          });
        }

        if (taskStatus === 'interrupted') {
          if (step.status === 'pending' || step.status === 'running') {
            step.status = 'interrupted';
          }
          runningActions.forEach((action) => {
            action.status = 'interrupted';
          });
        }
      });
    }

    return steps;
}

function useProcessedSteps(events: TraceEvent[], taskStatus?: string): ProcessedStep[] {
  const { t, tDynamic } = useI18n();
  return useMemo(
    () => processTraceEvents(events, t, taskStatus, tDynamic),
    [events, taskStatus, t, tDynamic],
  );
}


// --- Specialized Tool Renderers ---

const ActionButton = ({ icon: Icon, onClick, title, className }: any) => (
  <button
    onClick={(e) => { e.stopPropagation(); onClick(e); }}
    className={cn("p-1 text-muted-foreground hover:text-foreground hover:bg-muted rounded transition-colors", className)}
    title={title}
  >
    <Icon className="w-3.5 h-3.5" />
  </button>
);

const CopyButton = ({
  value,
  filesDisabled,
  title,
}: {
  value: unknown,
  filesDisabled: boolean,
  title?: string,
}) => {
  const { t } = useI18n();
  const [copied, setCopied] = useState(false);
  const copiedTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  useEffect(() => () => {
    if (copiedTimeoutRef.current !== null) clearTimeout(copiedTimeoutRef.current);
  }, []);
  const handleCopy = async (e: React.MouseEvent) => {
    e.stopPropagation();
    const text = filesDisabled
      ? serializeFilesDisabledPresentation(value)
      : formatActionContent(value);
    // Same cross-origin embed concern as ChatMessage's copy button: only show
    // the check mark once the write has actually succeeded, and report a
    // failed write instead of leaving the click without any reaction.
    if (!(await copyToClipboard(text))) {
      toast.error(t('common.copyFailed'));
      return;
    }
    setCopied(true);
    if (copiedTimeoutRef.current !== null) clearTimeout(copiedTimeoutRef.current);
    copiedTimeoutRef.current = setTimeout(() => {
      copiedTimeoutRef.current = null;
      setCopied(false);
    }, 2000);
  };
  return (
    <button
      onClick={handleCopy}
      className="p-1 text-muted-foreground hover:text-foreground hover:bg-muted rounded transition-colors"
      title={title || t('traceEventRenderer.copy')}
    >
      {copied ? <Check className="w-3.5 h-3.5 text-green-500" /> : <Copy className="w-3.5 h-3.5" />}
    </button>
  );
};

const ToolArtifactsDisplay = ({
  artifacts,
  filesDisabled,
  onFileClick,
  t,
}: {
  artifacts?: ToolArtifact[];
  filesDisabled: boolean;
  onFileClick?: (filePath: string, fileName: string) => void;
  t: Translate;
}) => {
  if (filesDisabled) {
    const safeArtifacts = (artifacts || []).filter(
      artifact => artifact && (artifact.display === undefined || artifact.display === 'inline'),
    );

    if (safeArtifacts.length === 0) return null;

    return (
      <div className="mt-4 grid gap-2">
        {safeArtifacts.map((artifact, index) => (
          <span
            key={`${artifact.filename || artifact.type || index}`}
            className="text-xs text-muted-foreground break-all"
          >
            {artifact.filename || artifact.type || t('traceEventRenderer.filePrefix')}
          </span>
        ))}
      </div>
    );
  }

  const displayArtifacts = (artifacts || []).filter(
    artifact => artifact && (artifact.preview_url || artifact.file_id) && (artifact.display === undefined || artifact.display === 'inline')
  );

  if (displayArtifacts.length === 0) return null;

  return (
    <div className="mt-4 grid gap-3">
      {displayArtifacts.map((artifact, index) => (
        <InlineFilePreview
          key={`${artifact.file_id || artifact.preview_url || index}`}
          source={{
            fileId: artifact.file_id,
            previewUrl: artifact.preview_url,
            filename: artifact.filename,
            mimeType: artifact.mime_type,
            type: artifact.type,
          }}
          openLabel={t('files.previewDialog.buttons.open')}
          loadErrorText={t('files.previewDialog.errors.loadFailed')}
          onFileClick={onFileClick}
        />
      ))}
    </div>
  );
};

const ToolOutputDisplay = ({
  action,
  filesDisabled,
  isRunning,
  t,
  onFileClick,
  onAgentClick,
}: {
  action: StepAction,
  filesDisabled: boolean,
  isRunning: boolean,
  t: any,
  onFileClick?: (filePath: string, fileName: string) => void,
  onAgentClick?: (agentId: string, agentName: string) => void,
}) => {
  const displayOutput = useMemo(() => (
    filesDisabled && action.data.rawResult !== undefined
      ? projectFilesDisabledToolResultPresentation(action.data.rawResult)
      : action.data.output
  ), [action.data.output, action.data.rawResult, filesDisabled]);

  return (
    <>
      <ToolArtifactsDisplay
        artifacts={action.data.artifacts}
        filesDisabled={filesDisabled}
        onFileClick={onFileClick}
        t={t}
      />
      {displayOutput !== undefined && displayOutput !== '' && (
        <div className="mt-4 flex flex-col gap-1.5">
          <div className="text-xs text-muted-foreground px-1 flex justify-between items-center">
            <span>{t('traceEventRenderer.output')}</span>
            <CopyButton value={displayOutput} filesDisabled={filesDisabled} />
          </div>
          <div className="p-3 bg-muted/30 border border-border/50 rounded-xl text-[10px] sm:text-xs overflow-x-auto">
            {typeof displayOutput === 'string' ? (
              <MarkdownRenderer
                content={filesDisabled ? serializeFilesDisabledPresentation(displayOutput) : displayOutput}
                filesDisabled={filesDisabled}
                onFileClick={onFileClick}
                onAgentClick={onAgentClick}
                className="prose-sm max-w-none"
              />
            ) : (
              <pre className="text-foreground/80 whitespace-pre-wrap break-all font-mono">
                {filesDisabled
                  ? serializeFilesDisabledPresentation(displayOutput)
                  : JSON.stringify(displayOutput, null, 2)}
              </pre>
            )}
          </div>
        </div>
      )}
      {(displayOutput === undefined || displayOutput === '') && isRunning && (
        <div className="mt-4 p-3 bg-muted/30 border border-border/50 rounded-xl text-muted-foreground italic flex items-center gap-2 text-xs">
          <Loader2 className="w-4 h-4 animate-spin" />
          {t('traceEventRenderer.executing')}
        </div>
      )}
    </>
  );
};

const ToolErrorDisplay = ({
  action,
  filesDisabled,
  t,
}: {
  action: StepAction,
  filesDisabled: boolean,
  t: any,
}) => {
  if (action.status === 'failed' && action.data.error) {
    return (
      <div className="mb-2 mt-2 p-3 bg-red-500/10 border border-red-500/30 rounded-xl text-red-400 whitespace-pre-wrap break-all text-xs">
        <span className="font-semibold">{t('traceEventRenderer.errorLabel')}</span> {formatActionContent(action.data.error, filesDisabled)}
      </div>
    );
  }
  return null;
};

const PythonToolRenderer = ({ action, filesDisabled, onOpenTerminal, isRunning, t, onFileClick, onAgentClick }: any) => {
  const code = filesDisabled
    ? formatActionContent(action.data.code, true)
    : action.data.code;
  const filePath = action.data.args?.file_path;
  const fileLabel = filesDisabled
    ? getFilesDisabledPresentationFileLabel(action.data.args)
    : filePath;
  return (
    <div className="pt-2">
      {code !== undefined && (
        <div className="flex flex-col gap-1.5">
          {fileLabel && (
            <div className="mb-1 flex">
              <span className="inline-flex px-2 py-1 bg-blue-500/10 text-blue-600 dark:text-blue-400 rounded-md font-mono text-[11px] items-center gap-1.5 border border-blue-500/20">
                <FileText className="w-3.5 h-3.5" />
                {fileLabel}
              </span>
            </div>
          )}
          <div className="text-xs text-muted-foreground px-1 flex justify-between items-center">
            <div className="flex items-center gap-2">
              <span>{t('traceEventRenderer.code')}</span>
            </div>
            <CopyButton value={code} filesDisabled={filesDisabled} />
          </div>
          <div className="p-3 bg-muted/30 border border-border/50 rounded-xl font-mono text-[10px] sm:text-xs overflow-x-auto relative group">
            <span className="absolute right-3 top-3 text-[10px] font-bold text-muted-foreground/50 select-none">PYTHON</span>
            <pre className="text-foreground/80 whitespace-pre-wrap break-all">{code}</pre>
          </div>
        </div>
      )}
      <ToolOutputDisplay action={action} filesDisabled={filesDisabled} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />
    </div>
  );
};

const BashToolRenderer = ({ action, filesDisabled, onOpenTerminal, isRunning, t, onFileClick, onAgentClick }: any) => {
  const command = filesDisabled
    ? formatActionContent(action.data.args?.command ?? action.data.args, true)
    : action.data.args?.command || JSON.stringify(action.data.args);
  return (
    <div className="pt-2">
      {command !== undefined && (
        <div className="flex flex-col gap-1.5">
          <div className="text-xs text-muted-foreground px-1 flex justify-between items-center">
            <span>{t('traceEventRenderer.command')}</span>
            <CopyButton value={command} filesDisabled={filesDisabled} />
          </div>
          <div className="p-3 bg-muted/30 border border-border/50 rounded-xl font-mono text-[10px] sm:text-xs overflow-x-auto text-foreground/80 whitespace-pre-wrap break-all">
            <span className="text-green-500/70 mr-2 select-none">$</span>
            {command}
          </div>
        </div>
      )}
      <ToolOutputDisplay action={action} filesDisabled={filesDisabled} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />
    </div>
  );
};

const SearchToolRenderer = ({ action, filesDisabled, isRunning, t, onFileClick, onAgentClick }: any) => {
  const query = filesDisabled
    ? formatActionContent(action.data.args?.query ?? action.data.args, true)
    : action.data.args?.query || JSON.stringify(action.data.args);
  return (
    <div className="pt-2">
      <div className="flex flex-col gap-1.5">
        <div className="text-xs text-muted-foreground px-1 flex justify-between items-center">
          <span>{t('traceEventRenderer.searchQuery')}</span>
          <CopyButton value={query} filesDisabled={filesDisabled} />
        </div>
        <div className="p-3 bg-muted/30 border border-border/50 rounded-xl text-xs flex items-start gap-2">
          <Search className="w-4 h-4 text-muted-foreground mt-0.5 shrink-0" />
          <span className="italic text-foreground/80 whitespace-pre-wrap break-all">{query}</span>
        </div>
      </div>
      <ToolOutputDisplay action={action} filesDisabled={filesDisabled} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />
    </div>
  );
};

const FileToolRenderer = ({ action, filesDisabled, onOpenTerminal, isRunning, t, onFileClick, onAgentClick }: any) => {
  const { args, tool } = action.data;
  const filePath = args?.file_path || args?.path;
  const fileLabel = filesDisabled
    ? getFilesDisabledPresentationFileLabel(args)
    : filePath;
  const rawContent = args?.content || args?.text || args?.code;
  const content = filesDisabled
    ? formatActionContent(rawContent, true)
    : rawContent;
  const fallbackText = !content
    ? (filesDisabled ? serializeFilesDisabledPresentation(args) : JSON.stringify(args, null, 2))
    : undefined;

  return (
    <div className="pt-2">
      <div className="flex flex-col gap-1.5">
        {fileLabel && (
          <div className="mb-1 flex">
            <span
              className={cn(
                "inline-flex px-2 py-1 bg-blue-500/10 text-blue-600 dark:text-blue-400 rounded-md font-mono text-[11px] items-center gap-1.5 border border-blue-500/20",
                !filesDisabled && "cursor-pointer hover:bg-blue-500/20 transition-colors",
              )}
              onClick={filesDisabled ? undefined : (e) => {
                e.stopPropagation();
                onOpenTerminal(String(content || fallbackText || ''), typeof action.data.output === 'string' ? action.data.output : JSON.stringify(action.data.output ?? ''), tool || 'file_tool', filePath);
              }}
              title={filesDisabled ? undefined : t('traceEventRenderer.previewFile')}
            >
              <FileText className="w-3.5 h-3.5" />
              {fileLabel}
            </span>
          </div>
        )}
        <div className="text-xs text-muted-foreground px-1 flex justify-between items-center">
          <div className="flex items-center gap-2">
            <span>{content ? (t('traceEventRenderer.content')) : (t('traceEventRenderer.args'))}</span>
          </div>
          <div className="flex items-center gap-1">
            {(content || fallbackText) && (
              <CopyButton value={content || fallbackText} filesDisabled={filesDisabled} />
            )}
          </div>
        </div>
        <div className="p-3 bg-muted/30 border border-border/50 rounded-xl font-mono text-[10px] sm:text-xs overflow-x-auto text-foreground/80 whitespace-pre-wrap break-all">
          {content ? (
            <pre className="whitespace-pre-wrap break-all">{String(content)}</pre>
          ) : (
            <span className="whitespace-pre-wrap break-all">{fallbackText}</span>
          )}
        </div>
      </div>
      <ToolOutputDisplay action={action} filesDisabled={filesDisabled} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />
    </div>
  );
};

const DefaultToolRenderer = ({ action, filesDisabled, isRunning, t, onFileClick, onAgentClick }: any) => {
  const args = filesDisabled
    ? serializeFilesDisabledPresentation(action.data.args)
    : JSON.stringify(action.data.args, null, 2);
  return (
    <div className="pt-2">
      <div className="flex flex-col gap-1.5">
        <div className="text-xs text-muted-foreground px-1 flex justify-between items-center">
          <span>{t('traceEventRenderer.args')}</span>
          <CopyButton value={args} filesDisabled={filesDisabled} />
        </div>
        <div className="p-3 bg-muted/30 border border-border/50 rounded-xl font-mono text-[10px] sm:text-xs overflow-x-auto text-foreground/80 whitespace-pre-wrap break-all">
          <pre className="whitespace-pre-wrap break-all">{args}</pre>
        </div>
      </div>
      <ToolOutputDisplay action={action} filesDisabled={filesDisabled} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />
    </div>
  );
};

const ToolDetailsRenderer = ({ action, filesDisabled, onOpenTerminal, isRunning, t, onFileClick, onAgentClick }: any) => {
  const toolName = action.data.tool;
  let rendererContent = null;
  if (toolName === 'python_executor' || toolName === 'execute_python_code') {
    rendererContent = <PythonToolRenderer action={action} filesDisabled={filesDisabled} onOpenTerminal={onOpenTerminal} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />;
  } else if (toolName === 'bash') {
    rendererContent = <BashToolRenderer action={action} filesDisabled={filesDisabled} onOpenTerminal={onOpenTerminal} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />;
  } else if (toolName === 'web_search' || toolName === 'tavily_web_search') {
    rendererContent = <SearchToolRenderer action={action} filesDisabled={filesDisabled} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />;
  } else if (toolName && (toolName.includes('file') || toolName === 'list_directory')) {
    rendererContent = <FileToolRenderer action={action} filesDisabled={filesDisabled} onOpenTerminal={onOpenTerminal} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />;
  } else {
    rendererContent = <DefaultToolRenderer action={action} filesDisabled={filesDisabled} isRunning={isRunning} t={t} onFileClick={onFileClick} onAgentClick={onAgentClick} />;
  }

  return (
    <div className="flex flex-col">
      <ToolErrorDisplay action={action} filesDisabled={filesDisabled} t={t} />
      {rendererContent}
    </div>
  );
};

// --- End Specialized Tool Renderers ---

// Step Action Item Component
interface StepActionItemProps {
  action: StepAction;
  filesDisabled: boolean;
  onViewDetail: (action: StepAction) => void;
  onOpenTerminal: (code: string, output: string, toolName: string, filePath?: string) => void;
  onFileClick?: (filePath: string, fileName: string) => void;
  onAgentClick?: (agentId: string, agentName: string) => void;
}

function StepActionItem({
  action,
  filesDisabled,
  onViewDetail,
  onOpenTerminal,
  onFileClick,
  onAgentClick,
}: StepActionItemProps) {
  const { t } = useI18n();
  const displayAction = useMemo(
    () => filesDisabled
      ? projectFilesDisabledPresentation(action) as StepAction
      : action,
    [action, filesDisabled],
  );
  const scrollRef = useRef<HTMLDivElement>(null);
  const [isExpanded, setIsExpanded] = useState(false);
  const [userToggled, setUserToggled] = useState(false);

  // Auto-expand/collapse logic
  useEffect(() => {
    if (userToggled) return;

    if (displayAction.status === 'running') {
      setIsExpanded(true);
    } else if (
      displayAction.status === 'completed' ||
      displayAction.status === 'failed' ||
      displayAction.status === 'interrupted'
    ) {
      setIsExpanded(false);
    }
  }, [displayAction.status, userToggled]);

  // Auto-scroll logic
  useEffect(() => {
    if (displayAction.status === 'running' && isExpanded && scrollRef.current) {
      const scrollElement = scrollRef.current.querySelector('[data-radix-scroll-area-viewport]') ||
        scrollRef.current.querySelector('[data-slot="scroll-area-viewport"]');
      if (scrollElement) {
        scrollElement.scrollTop = scrollElement.scrollHeight;
      }
    }
  }, [displayAction.data, displayAction.status, isExpanded]); // Re-run when data updates

  const handleToggle = () => {
    setIsExpanded(!isExpanded);
    setUserToggled(true);
  };

  const isRunning = displayAction.status === 'running';
  const isFailed = displayAction.status === 'failed';
  const isCompleted = displayAction.status === 'completed';
  const summaryMetaRef = useRef<HTMLDivElement>(null);
  const fixedMetaRef = useRef<HTMLDivElement>(null);
  const summaryMeasureRef = useRef<HTMLSpanElement>(null);
  const [hideToolSummary, setHideToolSummary] = useState(false);

  const summary = useMemo(() => {
    if (displayAction.type === 'llm') {
      if (displayAction.data.reasoning) {
        const clean = formatActionContent(
          displayAction.data.reasoning,
          filesDisabled,
        ).replace(/[\n\r\s]+/g, ' ').trim();
        return clean.length > 50 ? clean.slice(0, 50) + '...' : clean;
      }
      return null;
    }
    if (displayAction.type === 'tool') {
      const { tool, args, code } = displayAction.data;

      if (tool === 'python_executor' && code) {
        return `Python: ${code.slice(0, 50).replace(/[\n\r\s]+/g, ' ').trim()}...`;
      }
      if (tool === 'bash' && args?.command) {
        return `${t('traceEventRenderer.bashPrefix')} ${String(args.command).slice(0, 50)}...`;
      }
      if ((tool === 'web_search' || tool === 'tavily_web_search') && args?.query) {
        return `${t('traceEventRenderer.searchPrefix')} ${args.query}`;
      }

      if (args && typeof args === 'object') {
        if ('file_path' in args || 'path' in args) {
          const fileLabel = filesDisabled ? getFilesDisabledPresentationFileLabel(args) : (
            'file_path' in args ? String(args.file_path) : String(args.path)
          );
          return fileLabel ? `${t('traceEventRenderer.filePrefix')} ${fileLabel}` : null;
        }
        if ('query' in args) return `${t('traceEventRenderer.queryPrefix')} ${String(args.query)}`;
      }

      if (code) {
        const clean = code.replace(/[\n\r\s]+/g, ' ').trim();
        return clean.length > 50 ? clean.slice(0, 50) + '...' : clean;
      }

      if (args) {
        try {
          const str = filesDisabled
            ? serializeFilesDisabledPresentation(args)
            : JSON.stringify(args);
          return str.length > 50 ? str.slice(0, 50) + '...' : str;
        } catch (e) { return null; }
      }
    }
    if (displayAction.type === 'info' && displayAction.data.output) {
      const clean = formatActionContent(displayAction.data.output, filesDisabled).replace(/[\n\r\s]+/g, ' ').trim();
      return clean.length > 50 ? clean.slice(0, 50) + '...' : clean;
    }
    return null;
  }, [displayAction, filesDisabled, t]);

  const updateToolSummaryVisibility = useCallback(() => {
    if (displayAction.type !== 'tool' || !summary) {
      setHideToolSummary(false);
      return;
    }

    if (typeof window !== 'undefined' && window.innerWidth < 640) {
      setHideToolSummary(true);
      return;
    }

    const container = summaryMetaRef.current;
    const measure = summaryMeasureRef.current;
    const fixed = fixedMetaRef.current;

    if (!container || !measure) {
      setHideToolSummary(false);
      return;
    }

    const fixedWidth = fixed?.offsetWidth ?? 0;
    const availableWidth = container.clientWidth - fixedWidth - 8;
    setHideToolSummary(availableWidth <= 0 || measure.scrollWidth > availableWidth);
  }, [displayAction.type, summary]);

  useEffect(() => {
    updateToolSummaryVisibility();

    const resizeObserver = new ResizeObserver(() => {
      updateToolSummaryVisibility();
    });

    if (summaryMetaRef.current) resizeObserver.observe(summaryMetaRef.current);
    if (fixedMetaRef.current) resizeObserver.observe(fixedMetaRef.current);
    if (summaryMeasureRef.current) resizeObserver.observe(summaryMeasureRef.current);

    return () => {
      resizeObserver.disconnect();
    };
  }, [updateToolSummaryVisibility]);

  if (displayAction.data.statusLine) {
    return (
      <div className="flex flex-wrap items-center gap-x-2 gap-y-0.5 px-3 py-1.5 text-xs text-muted-foreground">
        <Info className="w-3.5 h-3.5 flex-shrink-0" />
        <span className="break-words [overflow-wrap:anywhere]">{displayAction.title}</span>
        {typeof displayAction.data.error === 'string' && displayAction.data.error && (
          <span className="break-words [overflow-wrap:anywhere] text-muted-foreground/70">
            {displayAction.data.error}
          </span>
        )}
      </div>
    );
  }

  if (displayAction.type === 'info' && displayAction.data.inline) {
    return (
      <div className="px-3 py-1.5">
        <MarkdownRenderer
          content={formatActionContent(displayAction.data.output, filesDisabled)}
          filesDisabled={filesDisabled}
          onFileClick={onFileClick}
          className="text-sm leading-relaxed text-foreground prose-neutral dark:prose-invert max-w-none [&>p]:mb-1.5 [&>p:last-child]:mb-0"
        />
      </div>
    );
  }

  if (displayAction.type === 'llm') {
    return (
      <div className="group transition-all duration-300">
        {displayAction.data.reasoning && (
          <MarkdownRenderer
            content={formatActionContent(
              displayAction.data.reasoning,
              filesDisabled,
            )}
            filesDisabled={filesDisabled}
            onFileClick={onFileClick}
            className="
                text-sm text-muted-foreground leading-relaxed
                prose-neutral dark:prose-invert max-w-none
                [&>p]:mb-2 [&>p:last-child]:mb-0
              "
          />
        )}
        {displayAction.status === 'failed' && displayAction.data.error && (
          <div className="text-red-400 text-sm mt-1 whitespace-pre-wrap">
            {t('traceEventRenderer.errorLabel')}{formatActionContent(
              displayAction.data.error,
              filesDisabled,
            )}
          </div>
        )}
      </div>
    );
  }

  return (
    <div className="group transition-all duration-300">
      <button
        onClick={handleToggle}
        className={cn(
          "w-full flex items-center justify-between py-3 px-3 text-xs transition-colors rounded-md border",
          isRunning ? "bg-primary/10 border-primary/20 text-primary" :
            isExpanded ? "bg-muted/50 border-border text-foreground" :
              "bg-muted/50 border-transparent hover:bg-muted/60 text-muted-foreground/80 hover:text-foreground"
        )}
      >
        <div className="flex flex-1 items-start gap-2 min-w-0">
          <div className="flex items-start gap-2 min-w-0">
            <span className="flex-shrink-0 flex items-center">
              {displayAction.type === 'tool' && <Wrench className="w-3.5 h-3.5" />}
              {displayAction.type === 'error' && <Info className="w-3.5 h-3.5 text-red-500" />}
              {displayAction.type === 'info' && <MessageSquare className="w-3.5 h-3.5" />}
            </span>

            <span className="font-medium break-words [overflow-wrap:anywhere]">{displayAction.title}</span>
          </div>

          <div ref={summaryMetaRef} className="relative flex items-center gap-1 min-w-0 flex-1 overflow-hidden">
            <div ref={fixedMetaRef} className="flex items-center gap-1 shrink-0">
              {displayAction.data.sandboxed && (
                <span className="inline-flex items-center gap-1 px-1.5 py-0.5 rounded text-[10px] font-medium bg-green-500/10 text-green-600 dark:text-green-400 border border-green-500/20 whitespace-nowrap flex-shrink-0">
                  <Shield className="w-3 h-3" />
                  {t('traceEventRenderer.sandboxedExecution')}
                </span>
              )}

              {isRunning && <Loader2 className="w-3 h-3 animate-spin ml-1 flex-shrink-0" />}
            </div>

            {summary && (displayAction.type !== 'tool' || !hideToolSummary) && (
              <span className="text-muted-foreground/50 font-normal ml-1 hidden sm:block min-w-0 truncate">
                - {summary}
              </span>
            )}
            {summary && displayAction.type === 'tool' && (
              <span
                ref={summaryMeasureRef}
                aria-hidden="true"
                className="pointer-events-none absolute invisible whitespace-nowrap"
              >
                - {summary}
              </span>
            )}
          </div>
        </div>
        <div className="flex items-center gap-2 flex-shrink-0">
          <span className="text-[10px] opacity-0 group-hover:opacity-100 transition-opacity text-muted-foreground/50">
            {new Date(displayAction.timestamp).toLocaleString([], {
              month: 'numeric',
              day: 'numeric',
              hour: '2-digit',
              minute: '2-digit',
              second: '2-digit'
            })}
          </span>
          {isExpanded ? <ChevronDown className="w-3 h-3 opacity-50" /> : <ChevronRight className="w-3 h-3 opacity-50" />}
        </div>
      </button>

      <AnimatePresence>
        {isExpanded && (
          <motion.div
            initial={{ height: 0, opacity: 0 }}
            animate={{ height: "auto", opacity: 1 }}
            exit={{ height: 0, opacity: 0 }}
            transition={{ duration: 0.2 }}
            className="overflow-hidden"
          >
            <ScrollArea ref={scrollRef} className="max-h-[300px] w-full mt-1 bg-muted/30 border border-border/50 rounded-md overflow-auto">
              <div
                className={cn(
                  "p-3 space-y-2 font-mono text-xs",
                  !filesDisabled && "cursor-pointer hover:bg-muted/50 transition-colors",
                )}
                onClick={filesDisabled ? undefined : () => onViewDetail(displayAction)}
              >
                {displayAction.type === 'tool' && (
                  <ToolDetailsRenderer
                    action={displayAction}
                    filesDisabled={filesDisabled}
                    onOpenTerminal={onOpenTerminal}
                    isRunning={isRunning}
                    t={t}
                    onFileClick={onFileClick}
                    onAgentClick={onAgentClick}
                  />
                )}

                {displayAction.type === 'error' && (
                  <div className="text-red-400 whitespace-pre-wrap">
                    {formatActionContent(
                      displayAction.data.error,
                      filesDisabled,
                    )}
                  </div>
                )}

                {displayAction.type === 'info' && (
                  <MarkdownRenderer
                    content={formatActionContent(displayAction.data.output, filesDisabled)}
                    filesDisabled={filesDisabled}
                    onFileClick={onFileClick}
                    className="text-sm leading-relaxed prose-neutral dark:prose-invert max-w-none"
                  />
                )}
              </div>
            </ScrollArea>
          </motion.div>
        )}
      </AnimatePresence>
    </div>
  );
}

// Step Item Component
interface StepItemProps {
  step: ProcessedStep;
  index: number;
  filesDisabled: boolean;
  onOpenTerminal: (code: string, output: string, toolName: string, filePath?: string) => void;
  onViewDetail: (action: StepAction) => void;
  onFileClick?: (filePath: string, fileName: string) => void;
  onAgentClick?: (agentId: string, agentName: string) => void;
  onAgentExecutionClick?: (execution: AgentExecutionSummary) => void;
  defaultExpanded?: boolean;
}

function StepItem({
  step,
  index,
  filesDisabled,
  onOpenTerminal,
  onViewDetail,
  onFileClick,
  onAgentClick,
  onAgentExecutionClick,
  defaultExpanded = false,
}: StepItemProps) {
  const { t } = useI18n();
  const isCompleted = step.status === 'completed';
  const isFailed = step.status === 'failed';
  const isPaused = step.status === 'paused' || step.status === 'waiting_for_user';
  const isInterrupted = step.status === 'interrupted';
  const [isExpanded, setIsExpanded] = useState(() => defaultExpanded || !isCompleted);
  const wasCompletedRef = useRef(isCompleted);
  const rawTitle = filesDisabled
    ? sanitizeFilesDisabledPresentationText(step.description || step.stepName)
    : step.description || step.stepName;
  const displayTitle =
    isCompleted && step.stepName === t('traceEventRenderer.taskExecution') && !step.description
      ? t('traceEventRenderer.thoughtProcess')
      : rawTitle;
  const workforceSummaries = step.actions.filter(
    (action) =>
      action.data.workforceSummary &&
      typeof action.data.output === 'string' &&
      action.data.output.trim(),
  );
  const processActions = step.actions.filter((action) => !action.data.workforceSummary);
  const usesAgentInspector = Boolean(step.agentExecution && onAgentExecutionClick);
  const canExpandProcess = processActions.length > 0 && !usesAgentInspector;
  const stepTitleContent = (
    <>
      {isCompleted ? (
        <CheckCircle2 className="w-5 h-5 text-green-500 mt-0.5" />
      ) : isFailed ? (
        <Info className="w-5 h-5 text-red-500 mt-0.5" />
      ) : isPaused ? (
        <Info className="w-5 h-5 text-yellow-500 mt-0.5" />
      ) : isInterrupted ? (
        <>
          <CircleSlash
            data-icon="interrupted"
            className="w-5 h-5 text-muted-foreground mt-0.5"
            aria-hidden="true"
          />
          <span className="sr-only">{t('agent.layout.status.interrupted')}</span>
        </>
      ) : (
        <Loader2 className="w-5 h-5 text-primary animate-spin mt-0.5" />
      )}
      <h3 className="min-w-0 flex-1 text-sm font-medium text-foreground break-words [overflow-wrap:anywhere]">
        {displayTitle}
      </h3>
    </>
  );

  useEffect(() => {
    if (isCompleted && !wasCompletedRef.current && !defaultExpanded) {
      setIsExpanded(false);
    }
    wasCompletedRef.current = isCompleted;
  }, [defaultExpanded, isCompleted]);

  const handleToggle = () => {
    setIsExpanded((expanded) => !expanded);
  };

  return (
    <motion.div
      initial={{ opacity: 0, y: 10 }}
      animate={{ opacity: 1, y: 0 }}
      transition={{ delay: 0.1 * (index + 1) }}
      className="space-y-3"
      data-step-id={step.stepId}
    >
      {/* Step Title */}
      <div className="flex w-full items-start gap-2 rounded-lg px-2 py-1 -ml-2 transition-colors hover:bg-muted/50 group/step">
        {usesAgentInspector ? (
          <div className="flex min-w-0 flex-1 items-start gap-2 text-left">
            {stepTitleContent}
          </div>
        ) : (
          <button
            type="button"
            className="flex min-w-0 flex-1 items-start gap-2 text-left"
            onClick={handleToggle}
            aria-expanded={isExpanded}
          >
            {stepTitleContent}
          </button>
        )}
        {step.agentExecution && onAgentExecutionClick && (
          <button
            type="button"
            className="mt-0.5 shrink-0 text-[11px] font-medium text-primary hover:underline"
            onClick={() => onAgentExecutionClick(step.agentExecution!)}
          >
            {t('traceEventRenderer.viewAgentExecution')}
          </button>
        )}
        {canExpandProcess && (
          <button
            type="button"
            className="mt-0.5 shrink-0 inline-flex items-center gap-1 rounded-full border border-border/60 bg-background/80 px-2 py-0.5 text-[11px] font-medium text-muted-foreground transition-colors group-hover/step:text-foreground"
            onClick={handleToggle}
            aria-expanded={isExpanded}
          >
            {isExpanded ? t('traceEventRenderer.hideProcess') : t('traceEventRenderer.showProcess')}
            {isExpanded ? (
              <ChevronDown className="w-3.5 h-3.5" />
            ) : (
              <ChevronRight className="w-3.5 h-3.5" />
            )}
          </button>
        )}
      </div>

      {workforceSummaries.map((action) => (
        <div key={`${action.id}-summary`} className="ml-7 pr-2 text-sm">
          <MarkdownRenderer
            content={filesDisabled
              ? serializeFilesDisabledPresentation(action.data.output)
              : String(action.data.output)}
            className="prose-sm leading-relaxed"
            filesDisabled={filesDisabled}
            onFileClick={onFileClick}
            onAgentClick={onAgentClick}
          />
        </div>
      ))}

      <AnimatePresence>
        {isExpanded && canExpandProcess && (
          <motion.div
            initial={{ height: 0, opacity: 0 }}
            animate={{ height: "auto", opacity: 1 }}
            exit={{ height: 0, opacity: 0 }}
            transition={{ duration: 0.2 }}
            className="overflow-hidden"
          >
            {/* Actions List (replaces nested Execution Details) */}
            <div className="ml-2.5 pl-6 border-l-2 border-border/40 space-y-2 pt-1 pb-2">
              {processActions.map((action) => (
                <StepActionItem
                  key={action.id}
                  action={action}
                  filesDisabled={filesDisabled}
                  onViewDetail={onViewDetail}
                  onOpenTerminal={onOpenTerminal}
                  onFileClick={onFileClick}
                  onAgentClick={onAgentClick}
                />
              ))}
            </div>
          </motion.div>
        )}
      </AnimatePresence>
    </motion.div>
  );
}

// Main TraceEventRenderer Component
export function TraceEventRenderer({ events, taskStatus, onOpenExecutionPlan, onAgentExecutionClick, defaultExpandSteps = false }: TraceEventRendererProps) {
  const { t } = useI18n();
  const { filesDisabled, openFilePreview, dispatch } = useApp();
  const sanitizedEvents = useMemo(() => sanitizeTraceEvents(events), [events]);
  const processStatus = resolveTraceProcessStatus({
    taskStatus,
    traceEvents: sanitizedEvents,
  });
  const steps = useProcessedSteps(sanitizedEvents, processStatus);
  const router = useRouter();


  const handleAgentClick = useCallback((agentId: string, agentName: string) => {
    router.push(getAgentTaskHref(agentId));
  }, [router]);

  const skillSelection = useMemo(() => {
    for (let i = sanitizedEvents.length - 1; i >= 0; i--) {
      const event = sanitizedEvents[i];
      if (event.event_type === 'skill_select_end') {
        if (event.data?.selected && event.data?.skill_name) {
          return event.data.skill_name as string;
        }
        return null;
      }
    }
    return null;
  }, [sanitizedEvents]);

  const hasExecutionPlan = useMemo(
    () => sanitizedEvents.some(isDagExecutionEvent),
    [sanitizedEvents],
  );

  const executionPlanStepCount = useMemo(() => {
    for (let index = sanitizedEvents.length - 1; index >= 0; index -= 1) {
      if (!isDagExecutionEvent(sanitizedEvents[index])) continue;
      const data = sanitizedEvents[index].data;
      if (!data || typeof data !== 'object') continue;

      const record = data as Record<string, unknown>;
      const planCandidates = [record, record.plan_data, record.current_plan, record.plan];
      for (const candidate of planCandidates) {
        if (!candidate || typeof candidate !== 'object') continue;
        const planSteps = (candidate as Record<string, unknown>).steps;
        if (Array.isArray(planSteps) && planSteps.length > 0) {
          return planSteps.length;
        }
      }
    }

    return steps.length > 0 ? steps.length : null;
  }, [sanitizedEvents, steps.length]);

  const executionPlanLabel = executionPlanStepCount === null
    ? t('chatPage.executionPlan.dagSection')
    : t(
      executionPlanStepCount === 1
        ? 'chatPage.executionPlan.dagSectionOne'
        : 'chatPage.executionPlan.dagSectionOther',
      { count: executionPlanStepCount },
    );

  const getFileNameFromPath = (path?: string) => {
    if (!path) return '';
    const parts = path.split('/');
    return parts[parts.length - 1] || path;
  };

  const handleOpenTerminal = useCallback((code: string, output: string, toolName: string, filePath?: string) => {
    if (filesDisabled) return;

    if (filePath && filePath.trim()) {
      const fileName = getFileNameFromPath(filePath) || `${toolName || 'terminal'}-execution.txt`;
      openFilePreview(filePath, fileName);
      return;
    }

    const fileName = `${toolName || 'terminal'}-execution.txt`;
    openFilePreview('', fileName);
    const contentSections: string[] = [];
    if (code && code.trim()) {
      contentSections.push(`${t('traceEventRenderer.executionCode')}\n\n${code.trim()}`);
    }
    if (output && String(output).trim()) {
      contentSections.push(`\n\n${t('traceEventRenderer.outputResult')}\n\n${String(output).trim()}`);
    }
    dispatch({ type: "SET_FILE_PREVIEW_CONTENT", payload: { content: contentSections.join('\n'), error: null } });
  }, [filesDisabled, openFilePreview, dispatch, t]);

  const handleViewActionDetail = useCallback((action: StepAction) => {
    if (filesDisabled) return;

    const title = `${action.title.replace(/\s+/g, '_')}.json`;
    openFilePreview('', title);

    let content = '';
    // Better formatting for specific types
    if (action.type === 'tool') {
      content = `${t('traceEventRenderer.toolLabel')}${action.data.tool}\n\n${t('traceEventRenderer.argumentsLabel')}\n${JSON.stringify(action.data.args, null, 2)}`;
      if (action.data.assistant_content) {
        content += `\n\n${t('traceEventRenderer.toolCallNote')}\n${action.data.assistant_content}`;
      }
      if (action.data.code) {
        content += `\n\n${t('traceEventRenderer.codeLabel')}\n${action.data.code}`;
      }
      if (action.data.output) {
        content += `\n\n${t('traceEventRenderer.outputLabel')}\n${typeof action.data.output === 'string' ? action.data.output : JSON.stringify(action.data.output, null, 2)}`;
      }
    } else if (action.type === 'llm') {
      content = `${t('traceEventRenderer.modelLabel')}${action.data.model}\n\n${t('traceEventRenderer.reasoningLabel')}\n${action.data.reasoning || t('traceEventRenderer.noReasoning')}`;
      if (action.data.tool_calls) {
        content += `\n\n${t('traceEventRenderer.toolCallsLabel')}\n${JSON.stringify(action.data.tool_calls, null, 2)}`;
      }
    } else if (action.data.error) {
      content = `${t('traceEventRenderer.errorTitle')}\n${String(action.data.error)}`;
    } else {
      content = JSON.stringify(action.data, null, 2);
    }

    dispatch({ type: "SET_FILE_PREVIEW_CONTENT", payload: { content, error: null } });
  }, [filesDisabled, openFilePreview, dispatch, t]);

  return (
    <div className="space-y-4">
      {hasExecutionPlan && onOpenExecutionPlan && (
        <button
          type="button"
          className="flex w-full items-center justify-between gap-3 rounded-lg border border-border/50 bg-muted/20 px-3 py-2 text-left transition-colors hover:border-border hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
          onClick={onOpenExecutionPlan}
          title={t('chatPage.executionPlan.tooltip')}
        >
          <div className="flex min-w-0 items-center gap-2">
            <GitMerge className="h-4 w-4 shrink-0 text-muted-foreground" />
            <span className="truncate text-sm font-medium text-foreground">
              {executionPlanLabel}
            </span>
          </div>
          <span className="flex shrink-0 items-center text-xs font-medium text-muted-foreground">
            {t('chatPage.executionPlan.view')}
            <ChevronRight className="ml-1 h-3.5 w-3.5" />
          </span>
        </button>
      )}
      {skillSelection && (
        <div className="bg-muted/30 border border-border/50 rounded-lg p-3 flex items-center gap-2">
          <Cpu className="w-4 h-4 text-primary" />
          <span className="text-sm">
            {t('traceEventRenderer.skillSelected')}: <span className="font-medium">{skillSelection}</span>
          </span>
        </div>
      )}
      <div className="flex gap-3">
        <div className="flex-1 space-y-4 overflow-hidden">
          {steps.map((step, index) => (
            <StepItem
              key={step.stepId}
              step={step}
              index={index}
              filesDisabled={filesDisabled}
              onOpenTerminal={handleOpenTerminal}
              onViewDetail={handleViewActionDetail}
              onFileClick={filesDisabled ? undefined : openFilePreview}
              onAgentClick={handleAgentClick}
              onAgentExecutionClick={onAgentExecutionClick}
              defaultExpanded={defaultExpandSteps}
            />
          ))}
        </div>
      </div>
    </div>
  );
}

export default TraceEventRenderer;