ummaya 0.2.4 → 0.2.5

package/tui/src/tools/DocumentPrimitive/documentDestinationPath.ts

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+
+const LOCAL_DOCUMENT_PATH_RE =
+  /(?:~|\/)[^\s"'<>]+?\.(?:hwpx|hwp|docx|pdf|xlsx|pptx|odt|ods|odp|doc|xls|ppt|csv|txt|md|json|xml|html)/giu
+
+export function lastLocalDocumentPath(text: string): string | undefined {
+  let latest: string | undefined
+  for (const match of text.matchAll(LOCAL_DOCUMENT_PATH_RE)) {
+    const rawPath = match[0]?.trim()
+    if (rawPath === undefined || rawPath === '') continue
+    latest = trimTrailingPunctuation(rawPath)
+  }
+  return latest
+}
+
+function trimTrailingPunctuation(path: string): string {
+  return path.replace(/[),.;:，。]+$/u, '')
+}

package/tui/src/tools/DocumentPrimitive/documentMutationGuard.ts

@@ -0,0 +1,22 @@
+import type { ValidationResult } from '../../Tool.js'
+import {
+  getFsImplementation,
+  resolveDeepestExistingAncestorSync,
+} from '../../utils/fsOperations.js'
+import { documentDerivativeMutationValidation } from '../WorkspaceToolAdapter/documentFormatGuards.js'
+
+export function documentDerivativeMutationValidationForResolvedTarget(
+  filePath: string,
+): ValidationResult | null {
+  const directValidation = documentDerivativeMutationValidation(filePath)
+  if (directValidation !== null) return directValidation
+  if (filePath.startsWith('\\\\') || filePath.startsWith('//')) return null
+
+  const resolvedPath = resolveDeepestExistingAncestorSync(
+    getFsImplementation(),
+    filePath,
+  )
+  if (resolvedPath === undefined || resolvedPath === filePath) return null
+
+  return documentDerivativeMutationValidation(resolvedPath)
+}

package/tui/src/tools/DocumentPrimitive/documentPatchNormalization.ts

@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import { createHash } from 'node:crypto'
+import {
+  enforceDocumentSourceApprovalForDispatch,
+  normalizeDocumentSourceSupportedPatchesForDispatch,
+} from './documentSourceVerification.js'
+
+const APPROVAL_TOKEN_RE = /승인|\bapprove\b/giu
+const APPROVAL_WORD_RE = /승인|\bapprove\b/iu
+const ISSUED_DRAFT_ID_RE = /^draft-[a-f0-9]{24}$/u
+const DRAFT_SHA256_RE = /^[a-f0-9]{64}$/u
+const DECISION_SPLIT_RE =
+  /[.!?。]+|\b(?:but|however|nevertheless|instead|rather|and)\b|(?:하지만|그러나|그렇지만|다만|지만)/iu
+const EXPLICIT_ENGLISH_APPROVAL_SEGMENT_RE =
+  /^(?:yes[,.]?\s+)?i\s+approve(?:\s+(?:this|the|that|current|revised|updated|final|draft|version|document|text|content|answer|change|changes))*[.!]?$/iu
+const EXPLICIT_KOREAN_APPROVAL_SEGMENT_RE =
+  /^(?:(?:지금|현재|이번|방금|수정한|이|그)\s*)?(?:(?:초안|문안|내용|답변|문서)\s*(?:은|는|을|를)?\s*)?승인(?:해|합니다|할게|하겠습니다)[.!。]?$/u
+const ENGLISH_NEGATION_PREFIX_RE =
+  /\b(?:do\s+not|don't|didn't|isn't|cannot|can't|won't|haven't|hasn't|hadn't|never|unable\s+to|refuse\s+to|decline\s+to|not\b)/iu
+const KOREAN_NEGATION_PREFIX_RE = /(?:불\s*|미\s*)$/u
+const KOREAN_NEGATION_SUFFIX_RE =
+  /^\s*(?:은|을|이|가|도|만|으로)?\s*(?:하지|않|안|못|거부|거절|반려|보류|취소|처리하지|보지|간주하지|할\s*수\s*없|아님|없)/u
+const EXPLICIT_REJECTION_RE =
+  /(?:\bno\b|\breject(?:ed)?\b|\bdisapprove(?:d)?\b|\bunapproved\b|\bdo\s+not\s+treat\s+(?:that|this|it)\s+as\s+approval\b|아니|불\s*승인|미\s*승인|거절|거부|반려|보류|취소|승인(?:으로)?\s*처리하지)/giu
+
+type StringPatch = {
+  readonly targetPath: string
+  readonly value: string
+}
+
+type ApprovedDraftFields = {
+  readonly draftId: string
+  readonly draftSha256: string
+}
+
+export function normalizeDocumentMutationPayloadsForDispatch(
+  args: Record<string, unknown>,
+  userText: string | undefined,
+): Record<string, unknown> {
+  const sourceNormalization = normalizeDocumentSourceSupportedPatchesForDispatch(
+    normalizeDocumentStylePayloadsForDispatch(
+      normalizeDocumentPatchPayloadsForDispatch(args),
+    ),
+    userText,
+  )
+  return enforceDocumentSourceApprovalForDispatch(
+    normalizeApprovedDraftPayloadForDispatch(sourceNormalization.args, userText),
+    sourceNormalization,
+  )
+}
+
+function normalizeDocumentPatchPayloadsForDispatch(
+  args: Record<string, unknown>,
+): Record<string, unknown> {
+  if (!Array.isArray(args.patches)) return args
+  return {
+    ...args,
+    patches: args.patches.map(normalizeDocumentPatchPayloadForDispatch),
+  }
+}
+
+function normalizeDocumentPatchPayloadForDispatch(patch: unknown): unknown {
+  const record = recordFrom(patch)
+  if (record === undefined || !Object.hasOwn(record, 'content')) return patch
+  const { content, ...withoutContent } = record
+  if (Object.hasOwn(withoutContent, 'value')) return withoutContent
+  return {
+    ...withoutContent,
+    value: content,
+  }
+}
+
+function normalizeDocumentStylePayloadsForDispatch(
+  args: Record<string, unknown>,
+): Record<string, unknown> {
+  if (!Array.isArray(args.styles)) return args
+  const styles = args.styles.filter(style => {
+    const record = recordFrom(style)
+    return record === undefined || Object.keys(record).length > 0
+  })
+  if (styles.length > 0) return styles.length === args.styles.length ? args : { ...args, styles }
+  const { styles: _styles, ...withoutStyles } = args
+  return withoutStyles
+}
+
+function normalizeApprovedDraftPayloadForDispatch(
+  args: Record<string, unknown>,
+  userText: string | undefined,
+): Record<string, unknown> {
+  const callerApproval = approvedDraftFieldsFromArgs(args)
+  const normalizedArgs = withoutApprovedDraftFields(args)
+  if (userText === undefined) return normalizedArgs
+  if (!hasAffirmativeApproval(userText)) return normalizedArgs
+  if (callerApproval !== undefined) {
+    return {
+      ...normalizedArgs,
+      approved_draft_id: callerApproval.draftId,
+      approved_draft_sha256: callerApproval.draftSha256,
+    }
+  }
+  const patches = stringPatchesFromArgs(normalizedArgs)
+  if (patches === undefined || patches.length === 0) return normalizedArgs
+  const approval = authoringApprovalForPatches(patches)
+  return {
+    ...normalizedArgs,
+    approved_draft_id: approval.draftId,
+    approved_draft_sha256: approval.draftSha256,
+  }
+}
+
+function withoutApprovedDraftFields(args: Record<string, unknown>): Record<string, unknown> {
+  const {
+    approved_draft_id: _approvedDraftId,
+    approved_draft_sha256: _approvedDraftSha256,
+    ...withoutApproval
+  } = args
+  return withoutApproval
+}
+
+function approvedDraftFieldsFromArgs(
+  args: Record<string, unknown>,
+): ApprovedDraftFields | undefined {
+  const draftId = stringField(args, 'approved_draft_id')
+  const draftSha256 = stringField(args, 'approved_draft_sha256')
+  if (draftId === undefined || draftSha256 === undefined) return undefined
+  if (!ISSUED_DRAFT_ID_RE.test(draftId)) return undefined
+  if (!DRAFT_SHA256_RE.test(draftSha256)) return undefined
+  return { draftId, draftSha256 }
+}
+
+function hasAffirmativeApproval(userText: string): boolean {
+  const decisions = decisionSegments(userText).flatMap(approvalDecisionFromSegment)
+  return decisions.at(-1) === true
+}
+
+function decisionSegments(userText: string): readonly string[] {
+  return userText
+    .split(DECISION_SPLIT_RE)
+    .map(segment => segment.trim())
+    .filter(segment => segment !== '')
+}
+
+function approvalDecisionFromSegment(segment: string): readonly boolean[] {
+  const decisions: Array<{ readonly index: number; readonly approved: boolean }> = []
+  for (const match of segment.matchAll(APPROVAL_TOKEN_RE)) {
+    const approvalToken = match[0]
+    const index = match.index
+    if (index !== undefined && isNegatedApprovalToken(segment, index, approvalToken.length)) {
+      decisions.push({ index, approved: false })
+    }
+  }
+  for (const match of segment.matchAll(EXPLICIT_REJECTION_RE)) {
+    const index = match.index
+    if (index !== undefined) {
+      decisions.push({ index, approved: false })
+    }
+  }
+  if (decisions.length === 0 && isExplicitApprovalSegment(segment)) {
+    decisions.push({ index: 0, approved: true })
+  }
+  return decisions
+    .sort((left, right) => left.index - right.index)
+    .map(decision => decision.approved)
+}
+
+function isExplicitApprovalSegment(segment: string): boolean {
+  const trimmedSegment = segment.trim()
+  return EXPLICIT_ENGLISH_APPROVAL_SEGMENT_RE.test(trimmedSegment) ||
+    EXPLICIT_KOREAN_APPROVAL_SEGMENT_RE.test(trimmedSegment)
+}
+
+function isNegatedApprovalToken(
+  segment: string,
+  index: number,
+  tokenLength: number,
+): boolean {
+  const beforeToken = segment.slice(0, index)
+  const afterToken = segment.slice(index + tokenLength)
+  return ENGLISH_NEGATION_PREFIX_RE.test(beforeToken) ||
+    KOREAN_NEGATION_PREFIX_RE.test(beforeToken) ||
+    KOREAN_NEGATION_SUFFIX_RE.test(afterToken)
+}
+
+function stringPatchesFromArgs(args: Record<string, unknown>): readonly StringPatch[] | undefined {
+  if (!Array.isArray(args.patches)) return []
+  const patches: StringPatch[] = []
+  for (const patch of args.patches) {
+    const record = recordFrom(patch)
+    if (record === undefined) return undefined
+    const targetPath = stringField(record, 'target_path')
+    const value = stringField(record, 'value')
+    if (targetPath === undefined || value === undefined) return undefined
+    patches.push({ targetPath, value })
+  }
+  return patches
+}
+
+function authoringApprovalForPatches(
+  patches: readonly StringPatch[],
+): { readonly draftId: string; readonly draftSha256: string } {
+  if (patches.length === 1) {
+    const patch = patches[0]
+    if (patch !== undefined) {
+      const draftSha256 = sha256Hex(patch.value)
+      return {
+        draftId: issuedAuthoringDraftId(patch.targetPath, draftSha256),
+        draftSha256,
+      }
+    }
+  }
+  const draftSha256 = sha256Hex(
+    patches
+      .map(patch => `${patch.targetPath}\0${sha256Hex(patch.value)}`)
+      .join('\0'),
+  )
+  return {
+    draftId: issuedAuthoringDraftId(authoringBundleTargetPath(patches), draftSha256),
+    draftSha256,
+  }
+}
+
+function issuedAuthoringDraftId(targetPath: string, draftSha256: string): string {
+  return `draft-${sha256Hex(`${targetPath}\0${draftSha256}`).slice(0, 24)}`
+}
+
+function authoringBundleTargetPath(patches: readonly StringPatch[]): string {
+  const targetPaths = patches.map(patch => patch.targetPath).join('\0')
+  return `bundle:${sha256Hex(targetPaths).slice(0, 24)}`
+}
+
+function stringField(
+  record: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = record[key]
+  return typeof value === 'string' && value.trim() !== '' ? value : undefined
+}
+
+function sha256Hex(value: string): string {
+  return createHash('sha256').update(value, 'utf8').digest('hex')
+}
+
+function recordFrom(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? Object.fromEntries(Object.entries(value))
+    : undefined
+}

package/tui/src/tools/DocumentPrimitive/documentSourceVerification.ts

@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import { detectPromptInjection } from '../WebFetchTool/sourceVerification.js'
+import {
+  hasApprovedDraft,
+  patchRequestsSourceSupport,
+  patchTargetPath,
+  recordFrom,
+  recordsFrom,
+  sha256Hex,
+  sourceSupportHasUnsafeUrl,
+  sourceVerificationRequested,
+  stringField,
+  withoutApprovalFields,
+  withoutPatches,
+} from './documentSourceVerificationFields.js'
+
+export const DOCUMENT_SOURCE_VERIFICATION_POLICY =
+  'source_supported_patch_requires_user_approval' as const
+
+type QuestionWaitingReason =
+  | 'missing_source_support'
+  | 'blocked_source_support'
+  | 'prompt_injection_source_support'
+  | 'stale_source_support'
+  | 'missing_user_approval'
+
+type QuestionWaitingField = {
+  readonly target_path: string
+  readonly reason: QuestionWaitingReason
+}
+
+type SourcePatchNormalization = {
+  readonly args: Record<string, unknown>
+  readonly sourceGovernedPatchCount: number
+  readonly sourceSupportedPatchCount: number
+}
+
+type SourceSupportEvaluation =
+  | {
+      readonly kind: 'supported'
+      readonly sourceSupport: Record<string, unknown>
+    }
+  | {
+      readonly kind: 'blocked'
+      readonly reason: QuestionWaitingReason
+    }
+
+const SHA256_RE = /^[a-f0-9]{64}$/u
+
+export function normalizeDocumentSourceSupportedPatchesForDispatch(
+  args: Record<string, unknown>,
+  userText: string | undefined,
+): SourcePatchNormalization {
+  if (!Array.isArray(args.patches)) {
+    return {
+      args,
+      sourceGovernedPatchCount: 0,
+      sourceSupportedPatchCount: 0,
+    }
+  }
+
+  const policyRequested = sourceVerificationRequested(args, userText)
+  const keptPatches: unknown[] = []
+  const questionWaitingFields: QuestionWaitingField[] = []
+  let sourceGovernedPatchCount = 0
+  let sourceSupportedPatchCount = 0
+
+  for (const patch of args.patches) {
+    const record = recordFrom(patch)
+    const patchRequiresSource = policyRequested || patchRequestsSourceSupport(record)
+    if (!patchRequiresSource) {
+      keptPatches.push(patch)
+      continue
+    }
+
+    sourceGovernedPatchCount += 1
+    const targetPath = patchTargetPath(record)
+    const evaluation = evaluateSourceSupport(record)
+    if (evaluation.kind === 'blocked') {
+      questionWaitingFields.push({
+        target_path: targetPath,
+        reason: evaluation.reason,
+      })
+      continue
+    }
+
+    sourceSupportedPatchCount += 1
+    keptPatches.push({
+      ...record,
+      source_support: evaluation.sourceSupport,
+    })
+  }
+
+  if (sourceGovernedPatchCount === 0) {
+    return {
+      args,
+      sourceGovernedPatchCount,
+      sourceSupportedPatchCount,
+    }
+  }
+
+  const nextArgs =
+    keptPatches.length > 0 ? { ...args, patches: keptPatches } : withoutPatches(args)
+
+  return {
+    args: withSourceVerificationMetadata(
+      nextArgs,
+      sourceSupportedPatchCount,
+      questionWaitingFields,
+    ),
+    sourceGovernedPatchCount,
+    sourceSupportedPatchCount,
+  }
+}
+
+export function enforceDocumentSourceApprovalForDispatch(
+  args: Record<string, unknown>,
+  normalization: SourcePatchNormalization,
+): Record<string, unknown> {
+  if (
+    normalization.sourceGovernedPatchCount === 0 ||
+    normalization.sourceSupportedPatchCount === 0 ||
+    hasApprovedDraft(args)
+  ) {
+    return failClosedIfNoPatches(args, normalization.sourceGovernedPatchCount)
+  }
+
+  const blockedFields = recordsFrom(args.patches).flatMap(patch => {
+    if (!patchRequestsSourceSupport(patch)) return []
+    return [
+      {
+        target_path: patchTargetPath(patch),
+        reason: 'missing_user_approval' as const,
+      },
+    ]
+  })
+  const keptPatches = recordsFrom(args.patches).filter(
+    patch => !patchRequestsSourceSupport(patch),
+  )
+  const withoutApproval = withoutApprovalFields(args)
+  const nextArgs =
+    keptPatches.length > 0
+      ? { ...withoutApproval, patches: keptPatches }
+      : withoutPatches(withoutApproval)
+
+  return failClosedIfNoPatches(
+    withSourceVerificationMetadata(nextArgs, 0, blockedFields),
+    normalization.sourceGovernedPatchCount,
+  )
+}
+
+function withSourceVerificationMetadata(
+  args: Record<string, unknown>,
+  sourceVerifiedPatchCount: number,
+  questionWaitingFields: readonly QuestionWaitingField[],
+): Record<string, unknown> {
+  const existingFields = Array.isArray(args.question_waiting_fields)
+    ? recordsFrom(args.question_waiting_fields)
+    : []
+  return {
+    ...args,
+    source_verification_policy: DOCUMENT_SOURCE_VERIFICATION_POLICY,
+    source_verified_patch_count: sourceVerifiedPatchCount,
+    question_waiting_fields: [...existingFields, ...questionWaitingFields],
+  }
+}
+
+function failClosedIfNoPatches(
+  args: Record<string, unknown>,
+  sourceGovernedPatchCount: number,
+): Record<string, unknown> {
+  if (sourceGovernedPatchCount === 0 || Array.isArray(args.patches)) {
+    return args
+  }
+  const {
+    approved_draft_id: _approvedDraftId,
+    approved_draft_sha256: _approvedDraftSha256,
+    destination_path: _destinationPath,
+    destination_display_name: _destinationDisplayName,
+    ...withoutMutation
+  } = args
+  return {
+    ...withoutMutation,
+    operation: 'inspect',
+  }
+}
+
+function evaluateSourceSupport(
+  patch: Record<string, unknown> | null,
+): SourceSupportEvaluation {
+  if (patch === null) return { kind: 'blocked', reason: 'missing_source_support' }
+  const value = stringField(patch, 'value')
+  if (value === undefined) return { kind: 'blocked', reason: 'missing_source_support' }
+  const support = recordFrom(patch.source_support) ?? recordFrom(patch.sourceSupport)
+  if (support === null) return { kind: 'blocked', reason: 'missing_source_support' }
+  if (support.state === 'blocked' || support.blocked_or_used === 'blocked') {
+    return { kind: 'blocked', reason: 'blocked_source_support' }
+  }
+  if (support.state !== 'source_supported') {
+    return { kind: 'blocked', reason: 'missing_source_support' }
+  }
+  if (sourceSupportHasUnsafeUrl(support)) {
+    return { kind: 'blocked', reason: 'blocked_source_support' }
+  }
+  if (sourceSupportHasPromptInjection(support)) {
+    return { kind: 'blocked', reason: 'prompt_injection_source_support' }
+  }
+  const sourceSha256 = stringField(support, 'source_sha256')
+  const citationHandle = stringField(support, 'citation_handle')
+  if (
+    sourceSha256 === undefined ||
+    citationHandle === undefined ||
+    !SHA256_RE.test(sourceSha256)
+  ) {
+    return { kind: 'blocked', reason: 'missing_source_support' }
+  }
+  if (sourceSha256 !== sha256Hex(value)) {
+    return { kind: 'blocked', reason: 'stale_source_support' }
+  }
+  return {
+    kind: 'supported',
+    sourceSupport: sanitizeSourceSupport(support),
+  }
+}
+
+function sourceSupportHasPromptInjection(
+  sourceSupport: Record<string, unknown>,
+): boolean {
+  if (sourceSupport.prompt_injection === 'detected') return true
+  const sourceText = stringField(sourceSupport, 'source_text')
+  return sourceText !== undefined && detectPromptInjection(sourceText) === 'detected'
+}
+
+function sanitizeSourceSupport(
+  sourceSupport: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    state: sourceSupport.state,
+    citation_handle: sourceSupport.citation_handle,
+    source_sha256: sourceSupport.source_sha256,
+    observed_at: sourceSupport.observed_at,
+    prompt_injection: sourceSupport.prompt_injection,
+  }
+}

package/tui/src/tools/DocumentPrimitive/documentSourceVerificationFields.ts

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import { createHash } from 'node:crypto'
+import { validatePublicWebFetchUrl } from '../WebFetchTool/urlSafety.js'
+
+const SOURCE_VERIFICATION_TEXT_RE =
+  /(근거|출처|검증|source[-\s]?support|source[-\s]?verification|citation|evidence)/iu
+
+const SOURCE_SUPPORT_URL_FIELDS = [
+  'source_url',
+  'sourceUrl',
+  'citation_url',
+  'citationUrl',
+] as const
+
+export function recordsFrom(value: unknown): readonly Record<string, unknown>[] {
+  if (!Array.isArray(value)) return []
+  return value.flatMap(item => {
+    const record = recordFrom(item)
+    return record === null ? [] : [record]
+  })
+}
+
+export function recordFrom(value: unknown): Record<string, unknown> | null {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? Object.fromEntries(Object.entries(value))
+    : null
+}
+
+export function stringField(
+  record: Record<string, unknown> | null,
+  key: string,
+): string | undefined {
+  if (record === null) return undefined
+  const value = record[key]
+  return typeof value === 'string' && value.trim() !== '' ? value : undefined
+}
+
+export function sha256Hex(value: string): string {
+  return createHash('sha256').update(value, 'utf8').digest('hex')
+}
+
+export function sourceVerificationRequested(
+  args: Record<string, unknown>,
+  userText: string | undefined,
+): boolean {
+  if (
+    args.requires_source_verification === true ||
+    args.source_verification_required === true
+  ) {
+    return true
+  }
+  const instruction = stringField(args, 'instruction')
+  const text = `${instruction ?? ''}\n${userText ?? ''}`
+  return SOURCE_VERIFICATION_TEXT_RE.test(text)
+}
+
+export function patchRequestsSourceSupport(
+  record: Record<string, unknown> | null,
+): boolean {
+  if (record === null) return false
+  return record.requires_source_verification === true ||
+    record.source_verification_required === true ||
+    record.source_support !== undefined ||
+    record.sourceSupport !== undefined
+}
+
+export function sourceSupportHasUnsafeUrl(
+  sourceSupport: Record<string, unknown>,
+): boolean {
+  for (const field of SOURCE_SUPPORT_URL_FIELDS) {
+    const value = stringField(sourceSupport, field)
+    if (value !== undefined && !validatePublicWebFetchUrl(value).ok) {
+      return true
+    }
+  }
+  return false
+}
+
+export function hasApprovedDraft(args: Record<string, unknown>): boolean {
+  return typeof args.approved_draft_id === 'string' &&
+    typeof args.approved_draft_sha256 === 'string'
+}
+
+export function withoutApprovalFields(
+  args: Record<string, unknown>,
+): Record<string, unknown> {
+  const {
+    approved_draft_id: _approvedDraftId,
+    approved_draft_sha256: _approvedDraftSha256,
+    ...withoutApproval
+  } = args
+  return withoutApproval
+}
+
+export function withoutPatches(args: Record<string, unknown>): Record<string, unknown> {
+  const { patches: _patches, ...withoutPatchPayload } = args
+  return withoutPatchPayload
+}
+
+export function patchTargetPath(record: Record<string, unknown> | null): string {
+  return stringField(record, 'target_path') ?? 'unknown'
+}

package/tui/src/tools/DocumentPrimitive/modelVisibleOutput.ts

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+
+export function modelVisibleDocumentOutput(output: unknown): unknown {
+  return rewriteModelVisibleDocumentValue(output)
+}
+
+function rewriteModelVisibleDocumentValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(item => rewriteModelVisibleDocumentValue(item))
+  }
+  const record = recordFrom(value)
+  if (record === null) {
+    return value
+  }
+
+  const rewritten: Record<string, unknown> = {}
+  for (const [key, nested] of Object.entries(record)) {
+    rewritten[key] = rewriteModelVisibleDocumentValue(nested)
+  }
+
+  const displayLabel = nonEmptyString(rewritten.display_label)
+  if (displayLabel !== undefined && typeof rewritten.target_path === 'string') {
+    rewritten.target_path = displayLabel
+  }
+  return rewritten
+}
+
+function recordFrom(value: unknown): Record<string, unknown> | null {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? Object.fromEntries(Object.entries(value))
+    : null
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+  if (typeof value !== 'string') {
+    return undefined
+  }
+  const trimmed = value.trim()
+  return trimmed === '' ? undefined : trimmed
+}