refactor: enforce 800 line source limits

web/src/views/scripts/travelReimbursementFlowTiming.js

@@ -0,0 +1,191 @@
+export const FLOW_RUN_DETAIL_REFRESH_TIMEOUT_MS = 3000
+
+const FLOW_DURATION_MS_FIELDS = [
+  'duration_ms',
+  'elapsed_ms',
+  'latency_ms',
+  'total_duration_ms',
+  'execution_time_ms'
+]
+const FLOW_DURATION_SECOND_FIELDS = [
+  'duration_seconds',
+  'elapsed_seconds',
+  'latency_seconds',
+  'execution_time_seconds'
+]
+const FLOW_DURATION_AUTO_FIELDS = ['duration', 'elapsed', 'latency', 'execution_time']
+const FLOW_STARTED_AT_FIELDS = ['started_at', 'start_time', 'created_at', 'queued_at']
+const FLOW_FINISHED_AT_FIELDS = ['finished_at', 'completed_at', 'ended_at', 'end_time', 'updated_at']
+
+export function formatFlowDuration(ms) {
+  if (ms === null || ms === undefined || ms === '') {
+    return '--'
+  }
+  const numericValue = Number(ms)
+  if (!Number.isFinite(numericValue) || numericValue <= 0) {
+    return '--'
+  }
+  if (numericValue < 1000) {
+    return `${Math.max(0.1, numericValue / 1000).toFixed(1)}s`
+  }
+  if (numericValue < 10000) {
+    return `${(numericValue / 1000).toFixed(1)}s`
+  }
+  return `${Math.round(numericValue / 1000)}s`
+}
+
+function parseFlowTimestamp(value) {
+  if (value === null || value === undefined || value === '') {
+    return 0
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value > 0 && value < 10000000000 ? Math.round(value * 1000) : Math.round(value)
+  }
+  const timestamp = new Date(value).getTime()
+  return Number.isFinite(timestamp) ? timestamp : 0
+}
+
+function normalizeDurationValue(value, unit = 'ms') {
+  if (value === null || value === undefined || value === '') {
+    return null
+  }
+
+  let numericValue = Number(value)
+  let normalizedUnit = unit
+  if (typeof value === 'string') {
+    const text = value.trim()
+    const match = text.match(/^(\d+(?:\.\d+)?)\s*(ms|毫秒|s|秒)?$/i)
+    if (match) {
+      numericValue = Number(match[1])
+      if (match[2]) {
+        normalizedUnit = ['s', '秒'].includes(match[2].toLowerCase()) ? 'seconds' : 'ms'
+      }
+    }
+  }
+
+  if (!Number.isFinite(numericValue) || numericValue <= 0) {
+    return null
+  }
+  if (normalizedUnit === 'seconds') {
+    return Math.round(numericValue * 1000)
+  }
+  if (normalizedUnit === 'auto') {
+    return Math.round(numericValue <= 300 ? numericValue * 1000 : numericValue)
+  }
+  return Math.round(numericValue)
+}
+
+function readFirstDurationField(source, fields, unit) {
+  if (!source || typeof source !== 'object') {
+    return null
+  }
+  for (const field of fields) {
+    if (!Object.prototype.hasOwnProperty.call(source, field)) {
+      continue
+    }
+    const durationMs = normalizeDurationValue(source[field], unit)
+    if (durationMs) {
+      return durationMs
+    }
+  }
+  return null
+}
+
+function resolveDurationFromFields(source) {
+  return (
+    readFirstDurationField(source, FLOW_DURATION_MS_FIELDS, 'ms')
+    || readFirstDurationField(source, FLOW_DURATION_SECOND_FIELDS, 'seconds')
+    || readFirstDurationField(source, FLOW_DURATION_AUTO_FIELDS, 'auto')
+  )
+}
+
+function readFirstTimestampField(source, fields) {
+  if (!source || typeof source !== 'object') {
+    return 0
+  }
+  for (const field of fields) {
+    const timestamp = parseFlowTimestamp(source[field])
+    if (timestamp) {
+      return timestamp
+    }
+  }
+  return 0
+}
+
+export function resolveStartedTimestamp(source) {
+  return readFirstTimestampField(source, FLOW_STARTED_AT_FIELDS)
+}
+
+export function resolveFinishedTimestamp(source) {
+  return readFirstTimestampField(source, FLOW_FINISHED_AT_FIELDS)
+}
+
+function resolveTimeRangeDurationMs(source) {
+  const startedAt = resolveStartedTimestamp(source)
+  const finishedAt = resolveFinishedTimestamp(source)
+  return finishedAt > startedAt ? finishedAt - startedAt : null
+}
+
+export function resolveSemanticPhaseDurations(run) {
+  const runStart = resolveStartedTimestamp(run)
+  const toolCalls = Array.isArray(run?.tool_calls) ? run.tool_calls : []
+  const firstToolStartedAt = toolCalls
+    .map((item) => resolveStartedTimestamp(item))
+    .filter((value) => value > 0)
+    .sort((left, right) => left - right)[0] || 0
+  const runFinishedAt = resolveFinishedTimestamp(run)
+  const semanticFinishedAt = firstToolStartedAt || runFinishedAt
+
+  if (!runStart || !semanticFinishedAt || semanticFinishedAt <= runStart) {
+    return { intentMs: null, extractionMs: null }
+  }
+
+  const totalMs = semanticFinishedAt - runStart
+  const intentMs = Math.max(120, Math.round(totalMs * 0.35))
+  const extractionMs = Math.max(160, totalMs - intentMs)
+  return {
+    intentMs,
+    extractionMs
+  }
+}
+
+export function resolveToolCallDurationMs(toolCall, index, toolCalls, run) {
+  const response = toolCall?.response_json && typeof toolCall.response_json === 'object'
+    ? toolCall.response_json
+    : {}
+  const explicitDuration = resolveDurationFromFields(toolCall)
+    || resolveTimeRangeDurationMs(toolCall)
+    || resolveDurationFromFields(response)
+    || resolveTimeRangeDurationMs(response)
+  if (explicitDuration) {
+    return explicitDuration
+  }
+
+  const startedAt = resolveStartedTimestamp(toolCall)
+  if (!startedAt) {
+    return null
+  }
+
+  const nextStartedAt = resolveStartedTimestamp(toolCalls[index + 1])
+  const runFinishedAt = resolveFinishedTimestamp(run)
+  const finishedAt = nextStartedAt > startedAt ? nextStartedAt : (runFinishedAt > startedAt ? runFinishedAt : 0)
+
+  if (!finishedAt || finishedAt <= startedAt) {
+    return null
+  }
+
+  return finishedAt - startedAt
+}
+
+export function summarizeVisibleToolText(value) {
+  const text = String(value || '')
+    .replace(/\|[^\n]*\|/g, '')
+    .replace(/\*\*/g, '')
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean) || ''
+  if (!text) {
+    return ''
+  }
+  return text.length > 80 ? `${text.slice(0, 80)}...` : text
+}