Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

10.2 KB
Raw Blame
import { useMemo } from 'react';
import { FilePenLine, FilePlus2 } from 'lucide-react';
import { parseJsonField, parseJsonFieldOccurrences } from '@librechat/chat';
import {
  toolPanelSpacingClassName,
  useFollowScroll,
  useToolCallIntent,
} from '@librechat/chat/react';
import {
  DiffView,
  BareStatus,
  diffPreviewText,
  TOOL_ROW_CLASSES,
  parseUnifiedDiff,
  buildEditPreviewDiff,
} from '@librechat/chat/components';
import type { TAttachment, PartMetadata } from 'librechat-data-provider';
import type { TextEditPreview } from '@librechat/chat/components';
import ProgressText from '~/components/Chat/Messages/Content/ProgressText';
import useToolCallState from './useToolCallState';
import useLazyHighlight from './useLazyHighlight';
import CodeWindowHeader from './CodeWindowHeader';
import { AttachmentGroup } from './Attachment';
import { langFromPath } from './ReadFileCall';
import { useLocalize } from '~/hooks';
import { cn } from '~/utils';

type FileAuthoringToolName = 'create_file' | 'edit_file';

type ToolCallArgs = string | Record<string, unknown> | undefined;

function hasDiff(output: string): boolean {
  return /\n@@\s/.test(output) || output.includes('\n--- ') || output.includes('\n+++ ');
}

function parseArgsObject(args: ToolCallArgs): Record<string, unknown> | undefined {
  if (typeof args === 'object' && args !== null) {
    return args;
  }
  if (typeof args !== 'string') {
    return undefined;
  }
  try {
    const parsed = JSON.parse(args);
    if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
      return parsed as Record<string, unknown>;
    }
  } catch {
    return undefined;
  }
  return undefined;
}

function textValue(value: unknown): string {
  return typeof value === 'string' ? value : '';
}

function coerceJsonValue(value: unknown): unknown {
  if (typeof value !== 'string') {
    return value;
  }
  try {
    return JSON.parse(value);
  } catch {
    return value;
  }
}

/** Structured edits for the args preview. Never formatted into diff text:
 *  `buildEditPreviewDiff` renders them directly, so no separator has to be
 *  invented and later told apart from real content. */
function buildEditArgsPreview(args: ToolCallArgs): TextEditPreview[] {
  const parsed = parseArgsObject(args);
  const edits = coerceJsonValue(parsed?.edits);
  if (Array.isArray(edits) && edits.length > 0) {
    return edits
      .map((edit): TextEditPreview | undefined => {
        const coercedEdit = coerceJsonValue(edit);
        if (typeof coercedEdit !== 'object' || coercedEdit === null || Array.isArray(coercedEdit)) {
          return undefined;
        }
        const entry = coercedEdit as Record<string, unknown>;
        const oldText = textValue(entry.old_text);
        const newText = textValue(entry.new_text);
        return oldText || newText ? { oldText, newText } : undefined;
      })
      .filter((edit): edit is TextEditPreview => !!edit);
  }

  if (parsed) {
    const oldText = textValue(parsed.old_text);
    const newText = textValue(parsed.new_text);
    return oldText || newText ? [{ oldText, newText }] : [];
  }

  /** Partial JSON during streaming: pair up field occurrences in document order, covering both single-replacement and batched `edits` args */
  const oldTexts = parseJsonFieldOccurrences(args, 'old_text');
  const newTexts = parseJsonFieldOccurrences(args, 'new_text');
  const editCount = Math.max(oldTexts.length, newTexts.length);
  return Array.from({ length: editCount }, (_, index) => ({
    oldText: oldTexts[index] ?? '',
    newText: newTexts[index] ?? '',
  })).filter((edit) => edit.oldText || edit.newText);
}

export default function FileAuthoringCall({
  toolName,
  isSubmitting,
  runStepStatus,
  runStepDurationMs,
  initialProgress = 0.1,
  args,
  output = '',
  attachments,
  hideAttachments = false,
  onExpand,
}: {
  toolName: FileAuthoringToolName;
  initialProgress: number;
  isSubmitting: boolean;
  runStepStatus?: PartMetadata['runStepStatus'];
  runStepDurationMs?: PartMetadata['runStepDurationMs'];
  args?: string | Record<string, unknown>;
  output?: string;
  attachments?: TAttachment[];
  hideAttachments?: boolean;
  onExpand?: () => void;
}) {
  const localize = useLocalize();
  const isCreate = toolName === 'create_file';
  /** `create_file` can overwrite an existing file (sandbox `overwrite: true`,
   *  or skill SKILL.md updates). The host-authored summary always opens with
   *  `Created`/`Updated`, so key the finished label off it for truthfulness. */
  const overwrote = isCreate && output.startsWith('Updated ');
  const filePath = useMemo(
    () => parseJsonField(args, 'path') || parseJsonField(args, 'file_path'),
    [args],
  );
  const intent = useToolCallIntent(args);
  const authoredContent = useMemo(() => parseJsonField(args, 'content'), [args]);
  const editArgs = useMemo(() => buildEditArgsPreview(args), [args]);
  const fileName = filePath.split('/').pop() || filePath || localize('com_ui_file').toLowerCase();
  const fileLang = useMemo(() => langFromPath(filePath), [filePath]);
  const outputIsDiff = hasDiff(output);
  /** A diff in the output supersedes the args preview: it carries the input
   *  with real file context. Only the output is ever PARSED; the args preview
   *  is built from structured edits, so it never round-trips through diff text
   *  where a separator could be confused with a real changed line. */
  const parsedDiff = useMemo(() => {
    if (outputIsDiff) {
      return parseUnifiedDiff(output);
    }
    return !isCreate && editArgs.length > 0 ? buildEditPreviewDiff(editArgs) : null;
  }, [outputIsDiff, output, isCreate, editArgs]);
  /** Plain text for the non-diff pane, and the copy payload either way. A diff
   *  in the output supersedes everything, including a create's authored
   *  content: `create_file` overwriting an existing file returns a summary plus
   *  a unified diff, and preferring the authored content there rendered that
   *  diff twice, once through `DiffView` and again verbatim as the raw output
   *  section. */
  const preview = useMemo(() => {
    if (outputIsDiff) {
      return output;
    }
    if (isCreate) {
      return authoredContent || output;
    }
    return parsedDiff ? diffPreviewText(parsedDiff) : output;
  }, [isCreate, authoredContent, outputIsDiff, output, parsedDiff]);
  const showOutputSection = !!output && preview !== output;
  let previewLang = 'plaintext';
  if (isCreate && authoredContent && preview === authoredContent) {
    previewLang = fileLang;
  }

  const { showCode, toggleCode, expandStyle, expandRef, phase, bare, rowRef } = useToolCallState({
    initialProgress,
    isSubmitting,
    output,
    hasInput: !!filePath || !!preview,
    /** An overwrite reads "Updated" on the row while the group header keeps the
     *  `create_file` name, so the row stays the only place that says it. */
    panelReady: !!preview && !overwrote,
    keepRow: intent != null,
    onExpand,
    runStepStatus,
  });

  const highlighted = useLazyHighlight(
    showCode && !parsedDiff && preview ? preview : undefined,
    previewLang,
  );
  const { ref: previewPaneRef, onScroll: onPreviewPaneScroll } = useFollowScroll<HTMLPreElement>(
    highlighted ?? preview,
    phase === 'running',
    showCode,
  );
  const Icon = isCreate && !overwrote ? FilePlus2 : FilePenLine;
  let finishedKey: 'com_ui_created_file' | 'com_ui_updated_file' | 'com_ui_edited_file' =
    'com_ui_edited_file';
  if (isCreate) {
    finishedKey = overwrote ? 'com_ui_updated_file' : 'com_ui_created_file';
  }

  const finishedText =
    phase === 'cancelled'
      ? localize('com_ui_cancelled')
      : (intent ?? localize(finishedKey, { 0: fileName }));

  return (
    <>
      <BareStatus active={bare} text={finishedText} />
      {!bare && (
        <div className={TOOL_ROW_CLASSES} ref={rowRef}>
          <ProgressText
            phase={phase}
            onClick={toggleCode}
            inProgressText={
              intent ??
              localize(isCreate ? 'com_ui_creating_file' : 'com_ui_editing_file', {
                0: fileName,
              })
            }
            finishedText={finishedText}
            durationMs={runStepDurationMs}
            icon={
              <Icon
                className={cn(
                  'text-text-secondary size-4 shrink-0',
                  phase === 'running' && 'animate-pulse',
                )}
                aria-hidden="true"
              />
            }
            hasInput={!!filePath || !!preview}
            isExpanded={showCode}
          />
        </div>
      )}
      <div style={expandStyle}>
        <div className="overflow-hidden" ref={expandRef}>
          {!!preview && (
            <div
              className={cn(
                toolPanelSpacingClassName,
                'border-border-light bg-surface-secondary overflow-hidden rounded-lg border',
              )}
            >
              <CodeWindowHeader
                language={fileName}
                code={preview}
                diffStats={
                  parsedDiff
                    ? { additions: parsedDiff.additions, deletions: parsedDiff.deletions }
                    : undefined
                }
              />
              {parsedDiff ? (
                <DiffView parsed={parsedDiff} />
              ) : (
                <pre
                  dir="ltr"
                  ref={previewPaneRef}
                  onScroll={onPreviewPaneScroll}
                  className="bg-surface-code-body max-h-[18.75rem] overflow-auto p-4 font-mono text-xs"
                >
                  <code className={`hljs language-${previewLang} !whitespace-pre`}>
                    {highlighted ?? preview}
                  </code>
                </pre>
              )}
              {showOutputSection && (
                <pre
                  dir="ltr"
                  className={cn(
                    'border-border-inset max-h-[18.75rem] overflow-auto border-t px-3 py-2 font-mono text-xs break-words whitespace-pre-wrap',
                    phase === 'failed' ? 'text-status-error' : 'text-text-secondary',
                  )}
                >
                  {output}
                </pre>
              )}
            </div>
          )}
        </div>
      </div>
      {!hideAttachments && attachments && attachments.length > 0 && (
        <AttachmentGroup attachments={attachments} />
      )}
    </>
  );
}