chore: import upstream snapshot with attribution

apps/sim/lib/copilot/tools/client/store-utils.ts

@@ -0,0 +1,184 @@
+import type { ComponentType } from 'react'
+import { Loader } from '@sim/emcn'
+import { FileText } from 'lucide-react'
+import { Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resources/types'
+import { isToolHiddenInUi } from '@/lib/copilot/tools/client/hidden-tools'
+import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-call-state'
+import { decodeVfsSegment } from '@/lib/copilot/vfs/path-utils'
+
+/** Respond tools are internal handoff tools shown with a friendly generic label. */
+const HIDDEN_TOOL_SUFFIX = '_respond'
+const INTERNAL_RESPOND_TOOL = 'respond'
+
+interface ClientToolDisplay {
+  text: string
+  icon: ComponentType<{ className?: string }>
+}
+
+export function resolveToolDisplay(
+  toolName: string | undefined,
+  state: ClientToolCallState,
+  params?: Record<string, unknown>
+): ClientToolDisplay | undefined {
+  if (!toolName) return undefined
+  if (isToolHiddenInUi(toolName)) return undefined
+
+  const specialDisplay = specialToolDisplay(toolName, state, params)
+  if (specialDisplay) return specialDisplay
+
+  return humanizedFallback(toolName, state)
+}
+
+function specialToolDisplay(
+  toolName: string,
+  state: ClientToolCallState,
+  params?: Record<string, unknown>
+): ClientToolDisplay | undefined {
+  if (toolName === INTERNAL_RESPOND_TOOL || toolName.endsWith(HIDDEN_TOOL_SUFFIX)) {
+    return {
+      text: formatRespondLabel(state),
+      icon: Loader,
+    }
+  }
+
+  if (toolName === ReadTool.id) {
+    const target = describeReadTarget(readStringParam(params, 'path'))
+    return {
+      text: formatReadingLabel(target, state),
+      icon: FileText,
+    }
+  }
+
+  return undefined
+}
+
+function formatRespondLabel(state: ClientToolCallState): string {
+  void state
+  return 'Gathering thoughts'
+}
+
+function readStringParam(
+  params: Record<string, unknown> | undefined,
+  key: string
+): string | undefined {
+  const value = params?.[key]
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}
+
+function formatReadingLabel(target: string | undefined, state: ClientToolCallState): string {
+  const suffix = target ? ` ${target}` : ''
+  switch (state) {
+    case ClientToolCallState.success:
+      return `Read${suffix}`
+    case ClientToolCallState.error:
+      return `Attempted to read${suffix}`
+    case ClientToolCallState.rejected:
+    case ClientToolCallState.aborted:
+      return `Skipped reading${suffix}`
+    default:
+      return `Reading${suffix}`
+  }
+}
+
+/**
+ * VFS paths store each segment percent-encoded (see {@link encodeVfsSegment}), so
+ * a read on "My Report.txt" arrives as "files/My%20Report.txt". Decode for
+ * display so the user sees the real file name. Falls back to the raw segment when
+ * it is not valid encoding (e.g. a literal "%" that was never encoded).
+ */
+function decodeVfsSegmentSafe(segment: string): string {
+  try {
+    return decodeVfsSegment(segment)
+  } catch {
+    return segment
+  }
+}
+
+function describeReadTarget(path: string | undefined): string | undefined {
+  if (!path) return undefined
+
+  const segments = path
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter(Boolean)
+    .map(decodeVfsSegmentSafe)
+
+  if (segments.length === 0) return undefined
+
+  const resourceType = VFS_DIR_TO_RESOURCE[segments[0]]
+  if (!resourceType) {
+    return stripExtension(segments[segments.length - 1])
+  }
+
+  if (resourceType === 'file') {
+    return describeFileReadTarget(segments)
+  }
+
+  if (resourceType === 'workflow') {
+    return stripExtension(getLeafResourceSegment(segments))
+  }
+
+  const resourceName = segments[1] || segments[segments.length - 1]
+  return stripExtension(resourceName)
+}
+
+// A workspace file is addressed as a directory of facets in the VFS
+// (files/{...path}/{name}/{facet}). `content` is the default facet — reading a
+// file means reading its content — so it carries no qualifier, matching a bare
+// `files/{...path}/{name}` read. The remaining facets are genuinely distinct, so
+// they keep a descriptive label.
+const FILE_FACET_LABELS: Record<string, string> = {
+  content: '',
+  'meta.json': 'metadata for',
+  style: 'style details for',
+  'compiled-check': 'the final file check for',
+}
+
+function describeFileReadTarget(segments: string[]): string {
+  const lastSegment = segments[segments.length - 1] || ''
+  const facetLabel = FILE_FACET_LABELS[lastSegment]
+  // Treat the suffix as a facet only when a real file name precedes it; otherwise
+  // the leaf is the file itself (e.g. a file literally named "content").
+  if (facetLabel !== undefined && segments.length > 2) {
+    const fileName = segments[segments.length - 2]
+    return facetLabel ? `${facetLabel} ${fileName}` : fileName
+  }
+  // Show just the file name, not the folder path — these are glanceable status
+  // lines, and the other resource types already render the leaf only.
+  return lastSegment
+}
+
+function getLeafResourceSegment(segments: string[]): string {
+  const lastSegment = segments[segments.length - 1] || ''
+  if (hasFileExtension(lastSegment) && segments.length > 1) {
+    return segments[segments.length - 2] || lastSegment
+  }
+  return lastSegment
+}
+
+function hasFileExtension(value: string): boolean {
+  return /\.[^/.]+$/.test(value)
+}
+
+function stripExtension(value: string): string {
+  return value.replace(/\.[^/.]+$/, '')
+}
+
+function humanizedFallback(
+  toolName: string,
+  state: ClientToolCallState
+): ClientToolDisplay | undefined {
+  const titleCaseName = toolName.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())
+  if (state === ClientToolCallState.error) {
+    const lowerCaseName = toolName.replace(/_/g, ' ').toLowerCase()
+    return { text: `Attempted to ${lowerCaseName}`, icon: Loader }
+  }
+  const stateVerb =
+    state === ClientToolCallState.success
+      ? 'Executed'
+      : state === ClientToolCallState.rejected || state === ClientToolCallState.aborted
+        ? 'Skipped'
+        : 'Executing'
+  return { text: `${stateVerb} ${titleCaseName}`, icon: Loader }
+}