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

🏋️ fix: Bound Host File Edits Outside the API Event Loop (#16677)

lia-by-librechat[bot]4217b9898af8
diff --git a/librechat.example.yaml b/librechat.example.yaml
index c01ff4eccf..1753bb69e9 100644
--- a/librechat.example.yaml
+++ b/librechat.example.yaml
@@ -698,6 +698,13 @@ endpoints:
# maxRecursionLimit: 100
# # (optional) Abort a run once a single streamed tool call's arguments exceed this many bytes.
# # Guards against runaway malformed tool-call generation. Defaults to 65536 (64 KiB); 0 disables.
+ # # Host-side skill/sandbox edits, not attached-worker edits. Over-budget calls write nothing.
+ # hostFileEdits:
+ # maxEdits: 100
+ # maxWorkBytes: 67108864 # cumulative matching/reconstruction bytes
+ # maxOccurrences: 100000 # cumulative occurrences across every edit/pass
+ # timeoutMs: 2000 # terminate an overlong worker job
+ # maxConcurrent: 2 # per API process; no waiting queue
# maxToolCallArgBytes: 65536
# # (optional) Abort a run once a single model generation emits more than this many stream events.
# # Defense in depth against looping provider streams. Disabled by default.
diff --git a/packages/api/src/agents/edits.spec.ts b/packages/api/src/agents/edits.spec.ts
index d57ab540ae..faa92c6b98 100644
--- a/packages/api/src/agents/edits.spec.ts
+++ b/packages/api/src/agents/edits.spec.ts
@@ -50,3 +50,9 @@ describe('normalizeEditArgs', () => {
expect(normalizeEditArgs({ edits: normalized })).toEqual(normalized);
});
});
+
+it('rejects oversized batches even when entries are valid or JSON-stringified', () => {
+ const edits = Array.from({ length: 101 }, () => ({ old_text: 'a', new_text: 'b' }));
+ expect(normalizeEditArgs({ edits })).toContain('limited to 100');
+ expect(normalizeEditArgs({ edits: JSON.stringify(edits) })).toContain('limited to 100');
+});
diff --git a/packages/api/src/agents/edits.ts b/packages/api/src/agents/edits.ts
index 23e32a060b..f2dfbc4e93 100644
--- a/packages/api/src/agents/edits.ts
+++ b/packages/api/src/agents/edits.ts
@@ -1,3 +1,5 @@
+import { HOST_FILE_EDIT_HARD_MAX_COUNT } from 'librechat-data-provider';
+
export type TextEdit = {
old_text: string;
new_text: string;
@@ -51,6 +53,9 @@ export function normalizeEditArgs(args: {
if (!Array.isArray(coercedEdits) || coercedEdits.length === 0) {
return 'Provide a non-empty edits array when edits is supplied.';
}
+ if (coercedEdits.length > HOST_FILE_EDIT_HARD_MAX_COUNT) {
+ return `File edits are limited to ${HOST_FILE_EDIT_HARD_MAX_COUNT} replacements per call.`;
+ }
const edits: TextEdit[] = [];
for (const rawEdit of coercedEdits) {
const edit = coerceJsonValue(rawEdit);
diff --git a/packages/api/src/agents/files/__fixtures__/edit-worker.cjs b/packages/api/src/agents/files/__fixtures__/edit-worker.cjs
new file mode 100644
index 0000000000..d9d554b068
--- /dev/null
+++ b/packages/api/src/agents/files/__fixtures__/edit-worker.cjs
@@ -0,0 +1,7 @@
+const { parentPort } = require('node:worker_threads');
+
+parentPort.on('message', ({ content }) => {
+ if (content === 'wait') return;
+ if (content === 'crash') throw new Error('PRIVATE-WORKER-DIAGNOSTIC');
+ parentPort.postMessage({ ok: true, result: { content, strategies: [] } });
+});
diff --git a/packages/api/src/agents/files/edit-worker.ts b/packages/api/src/agents/files/edit-worker.ts
new file mode 100644
index 0000000000..885a5d27d7
--- /dev/null
+++ b/packages/api/src/agents/files/edit-worker.ts
@@ -0,0 +1,28 @@
+import { parentPort } from 'node:worker_threads';
+import type { HostEditResult, HostEditWorkLimits } from './matching';
+import type { TextEdit } from '../edits';
+import { applyTextEdits, HostEditError } from './matching';
+
+export interface HostEditJob {
+ content: string;
+ edits: TextEdit[];
+ limits: HostEditWorkLimits;
+}
+
+export type HostEditReply = { ok: true; result: HostEditResult } | { ok: false; message: string };
+
+parentPort?.on('message', (job: HostEditJob) => {
+ let reply: HostEditReply;
+ try {
+ reply = { ok: true, result: applyTextEdits(job.content, job.edits, job.limits) };
+ } catch (error) {
+ reply = {
+ ok: false,
+ message:
+ error instanceof HostEditError
+ ? error.message
+ : 'File edit processing failed. Nothing was written.',
+ };
+ }
+ parentPort?.postMessage(reply);
+});
diff --git a/packages/api/src/agents/files/matching.spec.ts b/packages/api/src/agents/files/matching.spec.ts
new file mode 100644
index 0000000000..04e6523e9b
--- /dev/null
+++ b/packages/api/src/agents/files/matching.spec.ts
@@ -0,0 +1,60 @@
+import type { HostEditWorkLimits } from './matching';
+import { applyTextEdits } from './matching';
+
+const limits: HostEditWorkLimits = {
+ maxEdits: 100,
+ maxWorkBytes: 64 * 1024 * 1024,
+ maxOccurrences: 100000,
+ maxOutputBytes: 10 * 1024 * 1024,
+};
+
+describe('cumulative host edit accounting', () => {
+ it('charges input, matching, and reconstruction once for a full-context exact edit', () => {
+ const edits = [{ old_text: 'ax', new_text: 'bx' }];
+ expect(applyTextEdits('ax', edits, { ...limits, maxWorkBytes: 12 })).toEqual({
+ content: 'bx',
+ strategies: ['exact'],
+ });
+ expect(() => applyTextEdits('ax', edits, { ...limits, maxWorkBytes: 11 })).toThrow(
+ 'budget exceeded',
+ );
+ });
+
+ it('charges contraction as well as growth across a batch', () => {
+ const edits = [
+ { old_text: 'a', new_text: 'b', replace_all: true },
+ { old_text: 'b', new_text: 'a', replace_all: true },
+ { old_text: 'a', new_text: '', replace_all: true },
+ ];
+ expect(applyTextEdits('a', edits, { ...limits, maxWorkBytes: 16 })).toEqual({
+ content: '',
+ strategies: ['exact', 'exact', 'exact'],
+ });
+ expect(() => applyTextEdits('a', edits, { ...limits, maxWorkBytes: 15 })).toThrow(
+ 'budget exceeded',
+ );
+ });
+
+ it('remeasures UTF-8 sizes after each replacement and rejects oversized intermediates', () => {
+ const edits = [
+ { old_text: 'a', new_text: 'é', replace_all: true },
+ { old_text: 'é', new_text: '😀', replace_all: true },
+ { old_text: '😀', new_text: '', replace_all: true },
+ ];
+ expect(() => applyTextEdits('aa', edits, { ...limits, maxOutputBytes: 7 })).toThrow(
+ 'larger than',
+ );
+ expect(applyTextEdits('aa', edits, { ...limits, maxOutputBytes: 8 }).content).toBe('');
+ });
+
+ it('keeps exact offsets and output size after a tolerant replacement', () => {
+ const edits = [
+ { old_text: 'two words', new_text: 'é' },
+ { old_text: 'é', new_text: '😀' },
+ ];
+ expect(applyTextEdits('two words', edits, { ...limits, maxOutputBytes: 10 })).toEqual({
+ content: '😀',
+ strategies: ['whitespace-normalized', 'exact'],
+ });
+ });
+});
diff --git a/packages/api/src/agents/files/matching.ts b/packages/api/src/agents/files/matching.ts
new file mode 100644
index 0000000000..cca28ad237
--- /dev/null
+++ b/packages/api/src/agents/files/matching.ts
@@ -0,0 +1,468 @@
+import type { TextEdit } from '../edits';
+
+export interface HostEditWorkLimits {
+ maxEdits: number;
+ maxWorkBytes: number;
+ maxOccurrences: number;
+ maxOutputBytes: number;
+}
+
+export interface HostEditResult {
+ content: string;
+ strategies: string[];
+}
+
+export class HostEditError extends Error {
+ constructor(message: string) {
+ super(message);
+ this.name = 'HostEditError';
+ }
+}
+
+class EditWorkBudget {
+ private bytes = 0;
+ private occurrences = 0;
+
+ constructor(private readonly limits: HostEditWorkLimits) {}
+
+ scan(bytes: number): void {
+ this.bytes += bytes;
+ if (this.bytes > this.limits.maxWorkBytes) {
+ throw new HostEditError(
+ 'File edit processing budget exceeded; split the batch. Nothing was written.',
+ );
+ }
+ }
+
+ occurrence(): void {
+ if (++this.occurrences > this.limits.maxOccurrences) {
+ throw new HostEditError(
+ 'File edit occurrence budget exceeded; narrow the replacements. Nothing was written.',
+ );
+ }
+ }
+}
+
+type MatchedRange = { index: number; length: number };
+
+type MatchStatus =
+ | { status: 'matched'; index: number; length: number; strategy: string }
+ | { status: 'none' }
+ | { status: 'ambiguous'; strategy: string; count: number; matches: MatchedRange[] };
+
+/**
+ * Ranges a whitespace-tolerant strategy collects before it stops looking. An
+ * internal memory bound, not a policy: ambiguity only needs a second match, and
+ * exact `replace_all` never collects ranges at all.
+ */
+const MAX_EDIT_MATCHES = 10_000;
+
+/** Pieces buffered before they are flattened into one bounded output chunk. */
+const REPLACE_ALL_FLUSH_PIECES = 1_024;
+const REPLACE_ALL_FLUSH_CHARS = 16 * 1024;
+
+/**
+ * `content.split(needle).join(replacement)` without one array entry per match: pieces are
+ * flattened into chunks of bounded size, so memory tracks the output, not the match count.
+ */
+function replaceAllExact(
+ content: string,
+ needle: string,
+ replacement: string,
+ budget: EditWorkBudget,
+): string {
+ const chunks: string[] = [];
+ let pieces: string[] = [];
+ let pendingChars = 0;
+ const flush = () => {
+ chunks.push(pieces.join(''));
+ pieces = [];
+ pendingChars = 0;
+ };
+ let cursor = 0;
+ for (let index = content.indexOf(needle); index !== -1; index = content.indexOf(needle, cursor)) {
+ budget.occurrence();
+ pieces.push(content.slice(cursor, index), replacement);
+ pendingChars += index - cursor + replacement.length;
+ cursor = index + needle.length;
+ if (pieces.length >= REPLACE_ALL_FLUSH_PIECES || pendingChars >= REPLACE_ALL_FLUSH_CHARS) {
+ flush();
+ }
+ }
+ pieces.push(content.slice(cursor));
+ flush();
+ return chunks.join('');
+}
+
+/** Non-overlapping exact occurrences, counted without retaining their positions. */
+function countExactMatches(content: string, needle: string, budget: EditWorkBudget): number {
+ let count = 0;
+ for (
+ let index = content.indexOf(needle);
+ index !== -1;
+ index = content.indexOf(needle, index + needle.length)
+ ) {
+ budget.occurrence();
+ count++;
+ }
+ return count;
+}
+
+function countExactOccurrences(content: string, needle: string, budget: EditWorkBudget): number[] {
+ const indexes: number[] = [];
+ let start = 0;
+ while (start <= content.length && indexes.length <= MAX_EDIT_MATCHES) {
+ const index = content.indexOf(needle, start);
+ if (index === -1) {
+ break;
+ }
+ budget.occurrence();
+ indexes.push(index);
+ start = index + Math.max(1, needle.length);
+ }
+ return indexes;
+}
+
+function findExactMatch(content: string, needle: string, budget: EditWorkBudget): MatchStatus {
+ const matches = countExactOccurrences(content, needle, budget);
+ if (matches.length === 1) {
+ return { status: 'matched', index: matches[0], length: needle.length, strategy: 'exact' };
+ }
+ if (matches.length > 1) {
+ return {
+ status: 'ambiguous',
+ strategy: 'exact',
+ count: matches.length,
+ matches: matches.map((index) => ({ index, length: needle.length })),
+ };
+ }
+ return { status: 'none' };
+}
+
+function lineStarts(content: string): number[] {
+ const starts = [0];
+ for (let i = 0; i < content.length; i++) {
+ if (content[i] === '\n') {
+ starts.push(i + 1);
+ }
+ }
+ return starts;
+}
+
+function commonIndent(lines: string[]): number {
+ const indents = lines
+ .filter((line) => line.trim().length > 0)
+ .map((line) => {
+ const match = /^(\s*)/.exec(line);
+ return match ? match[1].length : 0;
+ });
+ return indents.length > 0 ? Math.min(...indents) : 0;
+}
+
+function stripCommonIndent(text: string): string {
+ const lines = text.split('\n');
+ const indent = commonIndent(lines);
+ if (indent === 0) {
+ return text;
+ }
+ return lines.map((line) => line.slice(Math.min(indent, line.length))).join('\n');
+}
+
+function findLineWindowMatch(
+ content: string,
+ needle: string,
+ strategy: 'line-trimmed' | 'indentation-flexible',
+ budget: EditWorkBudget,
+): MatchStatus {
+ const contentLines = content.split('\n');
+ const needleLines = needle.split('\n');
+ if (needleLines.length > contentLines.length) {
+ return { status: 'none' };
+ }
+
+ const starts = lineStarts(content);
+ const matches: Array<{ index: number; length: number }> = [];
+ const addMatch = (startLine: number) => {
+ const index = starts[startLine];
+ const endLine = startLine + needleLines.length;
+ const end = endLine < starts.length ? starts[endLine] - 1 : content.length;
+ budget.occurrence();
+ matches.push({ index, length: end - index });
+ };
+
+ if (strategy === 'line-trimmed') {
+ // Intern normalized lines so KMP compares integer IDs, not overlapping strings.
+ const ids = new Map<string, number>();
+ const pattern = needleLines.map((line) => {
+ const normalized = line.trimEnd();
+ let id = ids.get(normalized);
+ if (id == null) {
+ id = ids.size;
+ ids.set(normalized, id);
+ }
+ return id;
+ });
+ const prefixes = new Uint32Array(pattern.length);
+ let matched = 0;
+ for (let i = 1; i < pattern.length; i++) {
+ while (matched > 0 && pattern[i] !== pattern[matched]) {
+ matched = prefixes[matched - 1];
+ }
+ if (pattern[i] === pattern[matched]) matched++;
+ prefixes[i] = matched;
+ }
+
+ matched = 0;
+ for (let i = 0; i < contentLines.length && matches.length <= MAX_EDIT_MATCHES; i++) {
+ const id = ids.get(contentLines[i].trimEnd());
+ while (matched > 0 && id !== pattern[matched]) {
+ matched = prefixes[matched - 1];
+ }
+ if (id === pattern[matched]) matched++;
+ if (matched === pattern.length) {
+ addMatch(i - pattern.length + 1);
+ // Keep overlapping occurrences for ambiguity detection and replace_all.
+ matched = prefixes[matched - 1];
+ }
+ }
+ } else {
+ // This fallback runs only after line-trimmed and whitespace-normalized miss.
+ // Two nonblank needle lines imply at least two tokens: any indentation match
+ // would already have matched whitespace-normalized. An all-blank needle would
+ // already have matched line-trimmed. Only a single nonblank line remains.
+ let anchor = -1;
+ for (let i = 0; i < needleLines.length; i++) {
+ if (needleLines[i].trim().length === 0) continue;
+ if (anchor !== -1) return { status: 'none' };
+ anchor = i;
+ }
+ if (anchor === -1) return { status: 'none' };
+
+ const normalizedNeedle = stripCommonIndent(needle).split('\n');
+ const nonblank = new Uint32Array(contentLines.length + 1);
+ for (let i = 0; i < contentLines.length; i++) {
+ nonblank[i + 1] = nonblank[i] + Number(contentLines[i].trim().length > 0);
+ }
+ for (let i = anchor; i < contentLines.length && matches.length <= MAX_EDIT_MATCHES; i++) {
+ if (nonblank[i + 1] === nonblank[i]) continue;
+ const start = i - anchor;
+ const end = start + needleLines.length;
+ if (end > contentLines.length) break;
+ if (nonblank[end] - nonblank[start] !== 1) continue;
+ const indent = contentLines[i].length - contentLines[i].trimStart().length;
+ let matchesNeedle = true;
+ // Eligible windows have one nonblank line at a fixed offset. Each file line
+ // can belong to at most two of them, so these comparisons stay linear too.
+ for (let j = 0; j < needleLines.length; j++) {
+ if (contentLines[start + j].slice(indent) !== normalizedNeedle[j]) {
+ matchesNeedle = false;
+ break;
+ }
+ }
+ if (matchesNeedle) addMatch(start);
+ }
+ }
+
+ if (matches.length === 1) {
+ return { status: 'matched', ...matches[0], strategy };
+ }
+ if (matches.length > 1) {
+ return { status: 'ambiguous', strategy, count: matches.length, matches };
+ }
+ return { status: 'none' };
+}
+
+function escapeRegExp(value: string): string {
+ return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function findWhitespaceNormalizedMatch(
+ content: string,
+ needle: string,
+ budget: EditWorkBudget,
+): MatchStatus {
+ const tokens = needle.trim().split(/\s+/).filter(Boolean);
+ if (tokens.length < 2) {
+ return { status: 'none' };
+ }
+ const pattern = tokens.map(escapeRegExp).join('\\s+');
+ const regex = new RegExp(pattern, 'g');
+ const matches: Array<{ index: number; length: number }> = [];
+ let match: RegExpExecArray | null;
+ while (matches.length <= MAX_EDIT_MATCHES && (match = regex.exec(content)) != null) {
+ budget.occurrence();
+ matches.push({ index: match.index, length: match[0].length });
+ if (match[0].length === 0) {
+ regex.lastIndex += 1;
+ }
+ }
+ if (matches.length === 1) {
+ return { status: 'matched', ...matches[0], strategy: 'whitespace-normalized' };
+ }
+ if (matches.length > 1) {
+ return {
+ status: 'ambiguous',
+ strategy: 'whitespace-normalized',
+ count: matches.length,
+ matches,
+ };
+ }
+ return { status: 'none' };
+}
+
+function findReplacementMatch(
+ content: string,
+ needle: string,
+ budget: EditWorkBudget,
+ contentBytes: number,
+ needleBytes: number,
+): MatchStatus {
+ const scanBytes = contentBytes + needleBytes;
+ budget.scan(scanBytes);
+ const exact = findExactMatch(content, needle, budget);
+ if (exact.status !== 'none') {
+ return exact;
+ }
+ budget.scan(scanBytes);
+ const lineTrimmed = findLineWindowMatch(content, needle, 'line-trimmed', budget);
+ if (lineTrimmed.status !== 'none') {
+ return lineTrimmed;
+ }
+ budget.scan(scanBytes);
+ const whitespaceNormalized = findWhitespaceNormalizedMatch(content, needle, budget);
+ if (whitespaceNormalized.status !== 'none') {
+ return whitespaceNormalized;
+ }
+ budget.scan(scanBytes);
+ return findLineWindowMatch(content, needle, 'indentation-flexible', budget);
+}
+
+/** Keeps the earliest of any overlapping matches so replacements never collide. */
+function nonOverlapping(matches: readonly MatchedRange[]): MatchedRange[] {
+ const kept: MatchedRange[] = [];
+ let end = -1;
+ for (const match of [...matches].sort((a, b) => a.index - b.index)) {
+ if (match.index < end) continue;
+ kept.push(match);
+ end = match.index + match.length;
+ }
+ return kept;
+}
+
+function describeMatchCount(count: number): string {
+ return count > MAX_EDIT_MATCHES ? `more than ${MAX_EDIT_MATCHES}` : String(count);
+}
+
+/**
+ * The size `replace_all` would produce, computed before any replacement text is
+ * built so an oversized result is refused without allocating it.
+ */
+function projectedReplaceAllBytes(
+ content: string,
+ matches: readonly MatchedRange[],
+ contentBytes: number,
+ replacementBytes: number,
+): number {
+ let bytes = contentBytes;
+ for (const match of matches) {
+ bytes +=
+ replacementBytes -
+ Buffer.byteLength(content.slice(match.index, match.index + match.length), 'utf8');
+ }
+ return bytes;
+}
+
+function replaceMatches(content: string, matches: readonly MatchedRange[], text: string): string {
+ let result = '';
+ let cursor = 0;
+ for (const match of matches) {
+ result += content.slice(cursor, match.index) + text;
+ cursor = match.index + match.length;
+ }
+ return result + content.slice(cursor);
+}
+
+export function applyTextEdits(
+ content: string,
+ edits: TextEdit[],
+ limits: HostEditWorkLimits,
+): HostEditResult {
+ if (edits.length > limits.maxEdits) {
+ throw new HostEditError(
+ `File edits are limited to ${limits.maxEdits} replacements per call. Nothing was written.`,
+ );
+ }
+ const MAX_AUTHORING_BYTES = limits.maxOutputBytes;
+ const budget = new EditWorkBudget(limits);
+ if (Buffer.byteLength(content) > MAX_AUTHORING_BYTES) {
+ throw new HostEditError('File exceeds the authoring size limit. Nothing was written.');
+ }
+ let working = content;
+ const strategies: string[] = [];
+
+ for (const edit of edits) {
+ const workingBytes = Buffer.byteLength(working);
+ const oldBytes = Buffer.byteLength(edit.old_text);
+ const newBytes = Buffer.byteLength(edit.new_text);
+ budget.scan(oldBytes + newBytes);
+ if (edit.replace_all === true) budget.scan(workingBytes + oldBytes);
+ const exactCount =
+ edit.replace_all === true ? countExactMatches(working, edit.old_text, budget) : 0;
+ if (exactCount > 0) {
+ const projectedBytes = workingBytes + exactCount * (newBytes - oldBytes);
+ if (projectedBytes > MAX_AUTHORING_BYTES) {
+ throw new HostEditError(
+ `replace_all would make the file larger than ${MAX_AUTHORING_BYTES} bytes; nothing was written.`,
+ );
+ }
+ budget.scan(workingBytes + projectedBytes);
+ working = replaceAllExact(working, edit.old_text, edit.new_text, budget);
+ strategies.push(exactCount > 1 ? `exact x${exactCount}` : 'exact');
+ continue;
+ }
+ const match = findReplacementMatch(working, edit.old_text, budget, workingBytes, oldBytes);
+ if (match.status === 'none') {
+ throw new HostEditError('old_text did not match the file content.');
+ }
+ if (match.status === 'ambiguous' && edit.replace_all !== true) {
+ throw new HostEditError(
+ `old_text matched ${describeMatchCount(match.count)} locations with ${match.strategy}; make it unique or set replace_all before retrying.`,
+ );
+ }
+ if (match.status === 'ambiguous') {
+ if (match.count > MAX_EDIT_MATCHES) {
+ throw new HostEditError(
+ `replace_all with whitespace-tolerant matching is limited to ${MAX_EDIT_MATCHES} locations, and old_text matched more; copy the exact text or narrow old_text before retrying.`,
+ );
+ }
+ const matches = nonOverlapping(match.matches);
+ const projectedBytes = projectedReplaceAllBytes(working, matches, workingBytes, newBytes);
+ if (projectedBytes > MAX_AUTHORING_BYTES) {
+ throw new HostEditError(
+ `replace_all would make the file larger than ${MAX_AUTHORING_BYTES} bytes; nothing was written.`,
+ );
+ }
+ budget.scan(workingBytes + projectedBytes);
+ working = replaceMatches(working, matches, edit.new_text);
+ strategies.push(`${match.strategy} x${matches.length}`);
+ continue;
+ }
+ const projectedBytes =
+ workingBytes -
+ (match.strategy === 'exact'
+ ? oldBytes
+ : Buffer.byteLength(working.slice(match.index, match.index + match.length))) +
+ newBytes;
+ if (projectedBytes > MAX_AUTHORING_BYTES) {
+ throw new HostEditError(
+ `edited content exceeds ${MAX_AUTHORING_BYTES} byte limit; nothing was written.`,
+ );
+ }
+ budget.scan(workingBytes + projectedBytes);
+ working =
+ working.slice(0, match.index) + edit.new_text + working.slice(match.index + match.length);
+ strategies.push(match.strategy);
+ }
+
+ return { content: working, strategies };
+}
diff --git a/packages/api/src/agents/files/processing.spec.ts b/packages/api/src/agents/files/processing.spec.ts
new file mode 100644
index 0000000000..279c8d1045
--- /dev/null
+++ b/packages/api/src/agents/files/processing.spec.ts
@@ -0,0 +1,273 @@
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import type { TextEdit } from '../edits';
+import { createHostEditProcessor } from './processing';
+
+const workerPath = path.join(
+ path.dirname(require.resolve('@librechat/api')),
+ 'agents/files/edit-worker.cjs',
+);
+const edit: TextEdit = { old_text: 'a', new_text: 'b', replace_all: true };
+const amplification = (): TextEdit[] => [
+ ...Array.from({ length: 23 }, () => ({ old_text: 'a', new_text: 'aa', replace_all: true })),
+ ...Array.from({ length: 30 }, (_, i) => ({
+ old_text: i % 2 ? 'b' : 'a',
+ new_text: i % 2 ? 'a' : 'b',
+ replace_all: true,
+ })),
+ { old_text: 'a', new_text: '', replace_all: true },
+];
+
+describe('bounded host edit workers', () => {
+ const processor = createHostEditProcessor(workerPath);
+ afterAll(async () => processor.close());
+
+ it('rejects compact expansion and contraction while unrelated timers keep running', async () => {
+ let ticks = 0;
+ const timer = setInterval(() => {
+ ticks++;
+ }, 0);
+ try {
+ await expect(processor.apply('ax', amplification())).rejects.toThrow('budget exceeded');
+ expect(ticks).toBeGreaterThan(0);
+ } finally {
+ clearInterval(timer);
+ }
+ });
+
+ it('bounds occurrence work independently of scanned bytes', async () => {
+ await expect(processor.apply('aaa', [edit], { maxOccurrences: 2 })).rejects.toThrow(
+ 'occurrence budget',
+ );
+ });
+
+ it.each([9, 10])(
+ 'supports an ordinary exact edit of a %i MiB file with omitted limits',
+ async (mib) => {
+ const content = 'start\n' + 'x'.repeat(mib * 1024 * 1024 - 10) + '\nend';
+ const result = await processor.apply(content, [{ old_text: 'start', new_text: 'begin' }]);
+ expect(Buffer.byteLength(result.content)).toBe(mib * 1024 * 1024);
+ expect(result.content.startsWith('begin\n')).toBe(true);
+ expect(result.strategies).toEqual(['exact']);
+ },
+ );
+
+ it.each([
+ ['9 MiB ASCII', 'a'.repeat(9 * 1024 * 1024)],
+ ['10 MiB ASCII', 'a'.repeat(10 * 1024 * 1024)],
+ ['10 MiB UTF-8', 'é'.repeat(5 * 1024 * 1024)],
+ ])('supports full matching context for %s with omitted limits', async (_label, content) => {
+ const replacement = 'b' + content.slice(1);
+ const result = await processor.apply(content, [{ old_text: content, new_text: replacement }]);
+ expect(result.content).toBe(replacement);
+ expect(result.strategies).toEqual(['exact']);
+ });
+
+ it('supports replace_all with full 10 MiB context and a same-size replacement', async () => {
+ const content = 'a'.repeat(10 * 1024 * 1024);
+ const replacement = 'b' + content.slice(1);
+ await expect(
+ processor.apply(content, [{ old_text: content, new_text: replacement, replace_all: true }]),
+ ).resolves.toEqual({
+ content: replacement,
+ strategies: ['exact'],
+ });
+ });
+
+ it.each([false, true])(
+ 'admits a full-file replacement into a smaller result, replace_all=%s',
+ async (replaceAll) => {
+ const content = 'a'.repeat(10 * 1024 * 1024);
+ await expect(
+ processor.apply(content, [{ old_text: content, new_text: 'b', replace_all: replaceAll }]),
+ ).resolves.toEqual({
+ content: 'b',
+ strategies: ['exact'],
+ });
+ },
+ );
+
+ it('bounds every intermediate result, even when a later edit would shrink it', async () => {
+ await expect(
+ processor.apply(
+ 'a',
+ [
+ { old_text: 'a', new_text: 'x'.repeat(10 * 1024 * 1024 + 1) },
+ { old_text: 'x', new_text: '', replace_all: true },
+ ],
+ { maxWorkBytes: 64 * 1024 * 1024 },
+ ),
+ ).rejects.toThrow('byte limit');
+ });
+
+ it('retains ordered edits, exact-match strategy, and UTF-16 offsets', async () => {
+ await expect(
+ processor.apply('😀 a\r\na', [edit, { old_text: 'b', new_text: 'c', replace_all: true }]),
+ ).resolves.toEqual({
+ content: '😀 c\r\nc',
+ strategies: ['exact x2', 'exact x2'],
+ });
+ });
+
+ it('checks server-side count limits without starting work', async () => {
+ await expect(processor.apply('a', [edit, edit], { maxEdits: 1 })).rejects.toThrow(
+ 'limited to 1',
+ );
+ });
+
+ it('fails closed with a safe error on invalid configuration', async () => {
+ await expect(processor.apply('a', [edit], { maxConcurrent: 0 })).rejects.toThrow(
+ 'configuration is invalid',
+ );
+ });
+
+ it('rejects pre-cancelled jobs', async () => {
+ const controller = new AbortController();
+ controller.abort();
+ await expect(processor.apply('a', [edit], undefined, controller.signal)).rejects.toMatchObject({
+ name: 'AbortError',
+ });
+ });
+});
+
+describe('worker lifecycle', () => {
+ const fixture = path.join(__dirname, '__fixtures__', 'edit-worker.cjs');
+
+ it('sanitizes synchronous thread creation failures without consuming admission', async () => {
+ const processor = createHostEditProcessor(fixture);
+ const startup = jest
+ .spyOn(
+ jest.requireActual<typeof import('node:worker_threads')>('node:worker_threads'),
+ 'Worker',
+ )
+ .mockImplementationOnce(() => {
+ throw new Error('PRIVATE-STARTUP /operator/absolute/edit-worker.cjs');
+ });
+ try {
+ await expect(processor.apply('ready', [edit], { maxConcurrent: 1 })).rejects.toThrow(
+ /^File edit processing failed\. Nothing was written\.$/,
+ );
+ startup.mockRestore();
+ await expect(processor.apply('ready', [edit], { maxConcurrent: 1 })).resolves.toEqual({
+ content: 'ready',
+ strategies: [],
+ });
+ } finally {
+ startup.mockRestore();
+ await processor.close();
+ }
+ });
+
+ it('rejects oversized clone input before acquiring a worker', async () => {
+ const processor = createHostEditProcessor(fixture);
+ const startup = jest.spyOn(
+ jest.requireActual<typeof import('node:worker_threads')>('node:worker_threads'),
+ 'Worker',
+ );
+ try {
+ await expect(
+ processor.apply('a', [{ old_text: 'a'.repeat(512), new_text: 'b' }], {
+ maxWorkBytes: 1024,
+ }),
+ ).rejects.toThrow('budget exceeded');
+ expect(startup).not.toHaveBeenCalled();
+ } finally {
+ startup.mockRestore();
+ await processor.close();
+ }
+ });
+
+ it('has no queue and releases capacity only after cancellation terminates the worker', async () => {
+ const processor = createHostEditProcessor(fixture);
+ const controller = new AbortController();
+ const pending = processor.apply('wait', [edit], { maxConcurrent: 1 }, controller.signal);
+ try {
+ await expect(processor.apply('ready', [edit], { maxConcurrent: 1 })).rejects.toThrow('busy');
+ controller.abort();
+ await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
+ await expect(processor.apply('ready', [edit], { maxConcurrent: 1 })).resolves.toEqual({
+ content: 'ready',
+ strategies: [],
+ });
+ } finally {
+ controller.abort();
+ await processor.close();
+ }
+ });
+
+ it('terminates stalled jobs at the deadline and permits later reuse', async () => {
+ const processor = createHostEditProcessor(fixture);
+ try {
+ await expect(processor.apply('wait', [edit], { timeoutMs: 100 })).rejects.toThrow(
+ 'timed out',
+ );
+ await expect(processor.apply('ready', [edit])).resolves.toEqual({
+ content: 'ready',
+ strategies: [],
+ });
+ } finally {
+ await processor.close();
+ }
+ });
+
+ it.each([10_000, 10_001])(
+ 'rejects a reply at monotonic time %i before the timeout callback runs',
+ async (replyTime) => {
+ const processor = createHostEditProcessor(fixture);
+ const persisted = jest.fn();
+ const clock = jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(0)
+ .mockReturnValueOnce(0)
+ .mockReturnValue(replyTime);
+ try {
+ const result = processor.apply('ready', [edit], { timeoutMs: 10_000, maxConcurrent: 1 });
+ await expect(result.then(persisted)).rejects.toThrow('timed out');
+ expect(clock).toHaveBeenCalledTimes(3);
+ expect(persisted).not.toHaveBeenCalled();
+ clock.mockRestore();
+ await expect(processor.apply('ready', [edit], { maxConcurrent: 1 })).resolves.toEqual({
+ content: 'ready',
+ strategies: [],
+ });
+ } finally {
+ clock.mockRestore();
+ await processor.close();
+ }
+ },
+ );
+
+ it('accepts a reply strictly before the monotonic deadline', async () => {
+ const processor = createHostEditProcessor(fixture);
+ const clock = jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(0)
+ .mockReturnValueOnce(0)
+ .mockReturnValue(9999);
+ try {
+ await expect(processor.apply('ready', [edit], { timeoutMs: 10_000 })).resolves.toEqual({
+ content: 'ready',
+ strategies: [],
+ });
+ expect(clock).toHaveBeenCalledTimes(3);
+ } finally {
+ clock.mockRestore();
+ await processor.close();
+ }
+ });
+
+ it('sanitizes worker crashes and recovers capacity', async () => {
+ const processor = createHostEditProcessor(fixture);
+ try {
+ await expect(processor.apply('crash', [edit])).rejects.toThrow(
+ /^File edit processing failed\. Nothing was written\.$/,
+ );
+ await expect(processor.apply('ready', [edit])).resolves.toEqual({
+ content: 'ready',
+ strategies: [],
+ });
+ } finally {
+ await processor.close();
+ }
+ });
+});
diff --git a/packages/api/src/agents/files/processing.ts b/packages/api/src/agents/files/processing.ts
new file mode 100644
index 0000000000..327d0cd5c3
--- /dev/null
+++ b/packages/api/src/agents/files/processing.ts
@@ -0,0 +1,209 @@
+import path from 'node:path';
+import { Worker } from 'node:worker_threads';
+import { performance } from 'node:perf_hooks';
+import { hostFileEditLimitsSchema } from 'librechat-data-provider';
+import type { HostFileEditLimits } from 'librechat-data-provider';
+import type { HostEditJob, HostEditReply } from './edit-worker';
+import type { HostEditResult } from './matching';
+import type { TextEdit } from '../edits';
+import { HostEditError } from './matching';
+
+interface EditWorkerSlot {
+ worker: Worker;
+ idleTimer?: NodeJS.Timeout;
+ active: boolean;
+}
+
+/** No waiting queue: admitted jobs retain at most one input/output per bounded worker. */
+export function createHostEditProcessor(workerPath: string): {
+ apply: (
+ content: string,
+ edits: TextEdit[],
+ configured?: Partial<HostFileEditLimits>,
+ signal?: AbortSignal,
+ ) => Promise<HostEditResult>;
+ close: () => Promise<void>;
+} {
+ const slots = new Set<EditWorkerSlot>();
+ let active = 0;
+ let closed = false;
+
+ const remove = (slot: EditWorkerSlot): void => {
+ clearTimeout(slot.idleTimer);
+ slots.delete(slot);
+ };
+
+ const acquire = (): EditWorkerSlot => {
+ for (const slot of slots) {
+ if (slot.active) continue;
+ clearTimeout(slot.idleTimer);
+ slot.active = true;
+ slot.worker.ref();
+ return slot;
+ }
+ const worker = new Worker(workerPath, {
+ execArgv: [],
+ // The pure matcher never needs application services or an unbounded heap.
+ resourceLimits: { maxOldGenerationSizeMb: 128 },
+ });
+ const slot: EditWorkerSlot = { worker, active: true };
+ slots.add(slot);
+ worker.on('error', () => {
+ if (!slot.active) remove(slot);
+ });
+ worker.on('exit', () => remove(slot));
+ return slot;
+ };
+
+ return {
+ async apply(content, edits, configured, signal): Promise<HostEditResult> {
+ signal?.throwIfAborted();
+ const parsed = hostFileEditLimitsSchema.safeParse(configured ?? {});
+ if (!parsed.success) {
+ throw new HostEditError('File edit configuration is invalid. Nothing was written.');
+ }
+ const limits = parsed.data;
+ if (edits.length > limits.maxEdits) {
+ throw new HostEditError(
+ `File edits are limited to ${limits.maxEdits} replacements per call. Nothing was written.`,
+ );
+ }
+ if (closed || active >= limits.maxConcurrent) {
+ throw new HostEditError('File edit processing is busy; retry later. Nothing was written.');
+ }
+ const maxOutputBytes = 10 * 1024 * 1024;
+ if (content.length > maxOutputBytes) {
+ throw new HostEditError('File exceeds the authoring size limit. Nothing was written.');
+ }
+ // Bound UTF-16 clone bytes without scanning; the worker accounts UTF-8 processing.
+ let inputUnits = content.length;
+ for (const edit of edits) {
+ inputUnits += edit.old_text.length + edit.new_text.length;
+ if (inputUnits > limits.maxWorkBytes / 2) {
+ throw new HostEditError(
+ 'File edit processing budget exceeded; split the batch. Nothing was written.',
+ );
+ }
+ }
+ const deadline = performance.now() + limits.timeoutMs;
+ let slot: EditWorkerSlot;
+ try {
+ slot = acquire();
+ } catch {
+ throw new HostEditError('File edit processing failed. Nothing was written.');
+ }
+ active++;
+ const job: HostEditJob = {
+ content,
+ edits,
+ limits: { ...limits, maxOutputBytes },
+ };
+ return await new Promise<HostEditResult>((resolve, reject) => {
+ let settled = false;
+ const finish = async (
+ result: HostEditResult | undefined,
+ error: Error | undefined,
+ terminate: boolean,
+ ): Promise<void> => {
+ if (settled) return;
+ settled = true;
+ clearTimeout(timer);
+ signal?.removeEventListener('abort', abort);
+ slot.worker.off('message', message);
+ slot.worker.off('error', failed);
+ slot.worker.off('exit', exited);
+ if (terminate || closed) {
+ await slot.worker.terminate().catch(() => undefined);
+ remove(slot);
+ } else {
+ slot.active = false;
+ slot.worker.unref();
+ slot.idleTimer = setTimeout(() => {
+ remove(slot);
+ void slot.worker.terminate();
+ }, 30_000);
+ slot.idleTimer.unref();
+ }
+ active--;
+ if (error) reject(error);
+ else if (result) resolve(result);
+ };
+ const abort = (): void => {
+ void finish(
+ undefined,
+ new DOMException('File edit cancelled. Nothing was written.', 'AbortError'),
+ true,
+ );
+ };
+ const failed = (): void => {
+ void finish(
+ undefined,
+ new HostEditError('File edit processing failed. Nothing was written.'),
+ true,
+ );
+ };
+ const exited = (): void => failed();
+ const timeout = (): void => {
+ void finish(
+ undefined,
+ new HostEditError('File edit processing timed out. Nothing was written.'),
+ true,
+ );
+ };
+ const message = (reply: HostEditReply): void => {
+ if (signal?.aborted) {
+ abort();
+ return;
+ }
+ if (performance.now() >= deadline) {
+ timeout();
+ return;
+ }
+ void finish(
+ reply.ok ? reply.result : undefined,
+ reply.ok ? undefined : new HostEditError(reply.message),
+ false,
+ );
+ };
+ const timer = setTimeout(timeout, Math.max(0, deadline - performance.now()));
+ slot.worker.once('message', message);
+ slot.worker.once('error', failed);
+ slot.worker.once('exit', exited);
+ signal?.addEventListener('abort', abort, { once: true });
+ if (signal?.aborted) {
+ abort();
+ return;
+ }
+ try {
+ slot.worker.postMessage(job);
+ } catch {
+ failed();
+ }
+ });
+ },
+ async close(): Promise<void> {
+ closed = true;
+ await Promise.all(
+ [...slots].map(async (slot) => {
+ clearTimeout(slot.idleTimer);
+ await slot.worker.terminate();
+ remove(slot);
+ }),
+ );
+ },
+ };
+}
+
+let processor: ReturnType<typeof createHostEditProcessor> | undefined;
+
+export function applyHostTextEdits(
+ content: string,
+ edits: TextEdit[],
+ configured?: Partial<HostFileEditLimits>,
+ signal?: AbortSignal,
+): Promise<HostEditResult> {
+ processor ??= createHostEditProcessor(
+ path.join(path.dirname(require.resolve('@librechat/api')), 'agents/files/edit-worker.cjs'),
+ );
+ return processor.apply(content, edits, configured, signal);
+}
diff --git a/packages/api/src/agents/handlers.spec.ts b/packages/api/src/agents/handlers.spec.ts
index c9aed0897d..1727ad610e 100644
--- a/packages/api/src/agents/handlers.spec.ts
+++ b/packages/api/src/agents/handlers.spec.ts
@@ -1,3 +1,6 @@
+import { performance } from 'node:perf_hooks';
+import { applyTextEdits, HostEditError } from './files/matching';
+import * as hostEditProcessing from './files/processing';
jest.mock('./prewarm', () => ({
markSandboxReady: jest.fn(),
}));
@@ -5310,7 +5313,7 @@ describe('createToolExecuteHandler', () => {
it('normalizes each line once on a large multiline miss', async () => {
const content = ' '.repeat(19).concat('\n').repeat(20_000);
const oldText = '\t'.repeat(19).concat('\n').repeat(800) + 'missing';
- const { handler, saveSkillFileContent } = makeMatchingHandler(content);
+ const { saveSkillFileContent } = makeMatchingHandler(content);
const trimEnd = String.prototype.trimEnd;
const budget = 20_001 + 801;
let normalizations = 0;
@@ -5320,25 +5323,21 @@ describe('createToolExecuteHandler', () => {
if (++normalizations > budget) throw new Error('Repeated window normalization');
return trimEnd.call(this);
});
- let result: ToolExecuteResult;
+ let message = '';
try {
- [result] = await invokeHandler(handler, [
- {
- id: 'call_matching_large_miss',
- name: 'edit_file',
- args: {
- path: 'skills/matching-skill/references/a.md',
- old_text: oldText,
- new_text: 'changed',
- },
- },
- ]);
+ applyTextEdits(content, [{ old_text: oldText, new_text: 'changed' }], {
+ maxEdits: 100,
+ maxWorkBytes: 33554432,
+ maxOccurrences: 100000,
+ maxOutputBytes: 10 * 1024 * 1024,
+ });
+ } catch (error) {
+ message = error instanceof Error ? error.message : '';
} finally {
spy.mockRestore();
}
expect(normalizations).toBe(budget);
- expect(result.status).toBe('error');
- expect(result.errorMessage).toContain('old_text did not match');
+ expect(message).toContain('old_text did not match');
expect(saveSkillFileContent).not.toHaveBeenCalled();
});
@@ -5488,7 +5487,7 @@ describe('createToolExecuteHandler', () => {
},
);
- it('replaces any number of exact matches when the result fits', async () => {
+ it('replaces more than 10000 exact matches within the work budget', async () => {
const saveSkillFileContent = jest.fn(async () => ({
bytes: 10_001,
relativePath: 'references/a.md',
@@ -5535,6 +5534,299 @@ describe('createToolExecuteHandler', () => {
);
});
+ const amplificationEdits = () => [
+ ...Array.from({ length: 23 }, () => ({ old_text: 'a', new_text: 'aa', replace_all: true })),
+ ...Array.from({ length: 30 }, (_, i) => ({
+ old_text: i % 2 ? 'b' : 'a',
+ new_text: i % 2 ? 'a' : 'b',
+ replace_all: true,
+ })),
+ { old_text: 'a', new_text: '', replace_all: true },
+ ];
+
+ it.each(['SKILL.md', 'references/a.md'])(
+ 'rejects compact amplification atomically for %s without starving timers',
+ async (file) => {
+ const updateSkill = jest.fn();
+ const saveSkillFileContent = jest.fn();
+ const handler = makeAuthoringHandler({
+ getSkillByName: jest.fn(async () => ({
+ _id: SKILL_ID,
+ name: 'bounded-skill',
+ body: 'ax',
+ fileCount: 1,
+ version: 1,
+ })),
+ getSkillFileByPath: jest.fn(async () => ({
+ content: 'ax',
+ isBinary: false,
+ bytes: 2,
+ mimeType: 'text/markdown',
+ filepath: '/tmp/a.md',
+ file_id: 'revision-1',
+ source: 'local',
+ relativePath: 'references/a.md',
+ })),
+ updateSkill,
+ saveSkillFileContent,
+ });
+ let timerFired = false;
+ const timer = setTimeout(() => {
+ timerFired = true;
+ }, 0);
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'amplification',
+ name: 'edit_file',
+ args: { path: `skills/bounded-skill/${file}`, edits: amplificationEdits() },
+ },
+ ]);
+ clearTimeout(timer);
+ expect(result.status).toBe('error');
+ expect(result.errorMessage).toContain('budget exceeded');
+ expect(timerFired).toBe(true);
+ expect(updateSkill).not.toHaveBeenCalled();
+ expect(saveSkillFileContent).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(['SKILL.md', 'references/a.md'])(
+ 'does not persist a late worker reply for %s',
+ async (file) => {
+ const updateSkill = jest.fn();
+ const saveSkillFileContent = jest.fn();
+ const handler = makeAuthoringHandler(
+ {
+ getSkillByName: jest.fn(async () => ({
+ _id: SKILL_ID,
+ name: 'bounded-skill',
+ body: 'ax',
+ fileCount: 1,
+ version: 1,
+ })),
+ getSkillFileByPath: jest.fn(async () => ({
+ content: 'ax',
+ isBinary: false,
+ bytes: 2,
+ mimeType: 'text/markdown',
+ filepath: '/tmp/a.md',
+ file_id: 'revision-1',
+ source: 'local',
+ relativePath: 'references/a.md',
+ })),
+ updateSkill,
+ saveSkillFileContent,
+ },
+ {
+ req: {
+ user: { id: 'user-1' },
+ config: { endpoints: { agents: { hostFileEdits: { timeoutMs: 10000 } } } },
+ },
+ },
+ );
+ const clock = jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(0)
+ .mockReturnValueOnce(0)
+ .mockReturnValue(10000);
+ try {
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'late_reply',
+ name: 'edit_file',
+ args: { path: `skills/bounded-skill/${file}`, old_text: 'a', new_text: 'b' },
+ },
+ ]);
+ expect(result.status).toBe('error');
+ expect(result.errorMessage).toContain('timed out');
+ expect(updateSkill).not.toHaveBeenCalled();
+ expect(saveSkillFileContent).not.toHaveBeenCalled();
+ } finally {
+ clock.mockRestore();
+ }
+ },
+ );
+
+ it.each(['SKILL.md', 'references/a.md'])(
+ 'sanitizes operational edit failures before exposing %s results',
+ async (file) => {
+ const updateSkill = jest.fn();
+ const saveSkillFileContent = jest.fn();
+ const handler = makeAuthoringHandler({
+ getSkillByName: jest.fn(async () => ({
+ _id: SKILL_ID,
+ name: 'bounded-skill',
+ body: 'ax',
+ fileCount: 1,
+ version: 1,
+ })),
+ getSkillFileByPath: jest.fn(async () => ({
+ content: 'ax',
+ isBinary: false,
+ bytes: 2,
+ mimeType: 'text/markdown',
+ filepath: '/tmp/a.md',
+ file_id: 'revision-1',
+ source: 'local',
+ relativePath: 'references/a.md',
+ })),
+ updateSkill,
+ saveSkillFileContent,
+ });
+ const process = jest
+ .spyOn(hostEditProcessing, 'applyHostTextEdits')
+ .mockImplementationOnce(() => {
+ throw new Error('PRIVATE-STARTUP /operator/absolute/edit-worker.cjs');
+ });
+ try {
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'failed_startup',
+ name: 'edit_file',
+ args: { path: `skills/bounded-skill/${file}`, old_text: 'a', new_text: 'b' },
+ },
+ ]);
+ expect(result.errorMessage).toBe('File edit processing failed. Nothing was written.');
+ expect(JSON.stringify(result)).not.toContain('PRIVATE-STARTUP');
+ expect(JSON.stringify(result)).not.toContain('/operator/absolute');
+ expect(updateSkill).not.toHaveBeenCalled();
+ expect(saveSkillFileContent).not.toHaveBeenCalled();
+ } finally {
+ process.mockRestore();
+ }
+ },
+ );
+
+ it('honors deployment work limits across alternating edits, including contraction', async () => {
+ const saveSkillFileContent = jest.fn();
+ const handler = makeAuthoringHandler(
+ {
+ getSkillByName: jest.fn(async () => ({
+ _id: SKILL_ID,
+ name: 'bounded-skill',
+ body: '# Existing',
+ fileCount: 1,
+ version: 1,
+ })),
+ getSkillFileByPath: jest.fn(async () => ({
+ content: 'a'.repeat(1000),
+ isBinary: false,
+ bytes: 1000,
+ mimeType: 'text/markdown',
+ filepath: '/tmp/a.md',
+ file_id: 'revision-1',
+ source: 'local',
+ relativePath: 'references/a.md',
+ })),
+ saveSkillFileContent,
+ },
+ {
+ req: {
+ user: { id: 'user-1' },
+ config: {
+ endpoints: {
+ agents: { hostFileEdits: { maxWorkBytes: 12000, maxOccurrences: 100000 } },
+ },
+ },
+ },
+ },
+ );
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'alternating',
+ name: 'edit_file',
+ args: {
+ path: 'skills/bounded-skill/references/a.md',
+ edits: [
+ { old_text: 'a', new_text: 'b', replace_all: true },
+ { old_text: 'b', new_text: 'a', replace_all: true },
+ { old_text: 'a', new_text: 'b', replace_all: true },
+ { old_text: 'b', new_text: 'a', replace_all: true },
+ { old_text: 'a', new_text: '', replace_all: true },
+ ],
+ },
+ },
+ ]);
+ expect(result.errorMessage).toContain('processing budget exceeded');
+ expect(saveSkillFileContent).not.toHaveBeenCalled();
+ });
+
+ it('cancels host processing without writing an intermediate skill revision', async () => {
+ const controller = new AbortController();
+ const saveSkillFileContent = jest.fn();
+ const handler = makeAuthoringHandler({
+ runSignal: controller.signal,
+ getSkillByName: jest.fn(async () => ({
+ _id: SKILL_ID,
+ name: 'bounded-skill',
+ body: '# Existing',
+ fileCount: 1,
+ version: 1,
+ })),
+ getSkillFileByPath: jest.fn(async () => ({
+ content: 'ax',
+ isBinary: false,
+ bytes: 2,
+ mimeType: 'text/markdown',
+ filepath: '/tmp/a.md',
+ file_id: 'revision-1',
+ source: 'local',
+ relativePath: 'references/a.md',
+ })),
+ saveSkillFileContent,
+ });
+ const timer = setTimeout(() => controller.abort(), 0);
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'cancelled',
+ name: 'edit_file',
+ args: { path: 'skills/bounded-skill/references/a.md', edits: amplificationEdits() },
+ },
+ ]);
+ clearTimeout(timer);
+ expect(result.status).toBe('error');
+ expect(saveSkillFileContent).not.toHaveBeenCalled();
+ });
+
+ it('checks cancellation again after final permission checks and before saving', async () => {
+ const controller = new AbortController();
+ const saveSkillFileContent = jest.fn();
+ const handler = makeAuthoringHandler({
+ runSignal: controller.signal,
+ canEditSkill: jest.fn(async () => {
+ controller.abort();
+ return true;
+ }),
+ getSkillByName: jest.fn(async () => ({
+ _id: SKILL_ID,
+ name: 'bounded-skill',
+ body: '# Existing',
+ fileCount: 1,
+ version: 1,
+ })),
+ getSkillFileByPath: jest.fn(async () => ({
+ content: 'ax',
+ isBinary: false,
+ bytes: 2,
+ mimeType: 'text/markdown',
+ filepath: '/tmp/a.md',
+ file_id: 'revision-1',
+ source: 'local',
+ relativePath: 'references/a.md',
+ })),
+ saveSkillFileContent,
+ });
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'cancel_before_save',
+ name: 'edit_file',
+ args: { path: 'skills/bounded-skill/references/a.md', old_text: 'a', new_text: 'b' },
+ },
+ ]);
+ expect(result.status).toBe('error');
+ expect(saveSkillFileContent).not.toHaveBeenCalled();
+ });
+
it('blocks authoring hidden skills unless they were primed this turn', async () => {
const updateSkill = jest.fn();
const handler = makeAuthoringHandler(
@@ -5757,6 +6049,218 @@ describe('createToolExecuteHandler', () => {
});
}
+ it('rejects exact replacement amplification before writing a non-attached sandbox file', async () => {
+ const writeSandboxFile = jest.fn();
+ const handler = makeSandboxAuthoringHandler({
+ readSandboxFile: jest.fn(async () => ({ content: 'ax' })),
+ writeSandboxFile,
+ });
+ const edits = Array.from({ length: 23 }, () => ({
+ old_text: 'a',
+ new_text: 'aa',
+ replace_all: true,
+ }));
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'sandbox_amplification',
+ name: 'edit_file',
+ args: { path: '/mnt/data/a.txt', edits },
+ },
+ ]);
+ expect(result.status).toBe('error');
+ expect(result.errorMessage).toContain('budget exceeded');
+ expect(writeSandboxFile).not.toHaveBeenCalled();
+ });
+
+ it('does not persist a late non-attached sandbox edit', async () => {
+ const writeSandboxFile = jest.fn();
+ const handler = makeSandboxAuthoringHandler(
+ { readSandboxFile: jest.fn(async () => ({ content: 'ax' })), writeSandboxFile },
+ {
+ req: {
+ user: { id: 'user-1' },
+ config: { endpoints: { agents: { hostFileEdits: { timeoutMs: 10000 } } } },
+ },
+ },
+ );
+ const clock = jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(0)
+ .mockReturnValueOnce(0)
+ .mockReturnValue(10000);
+ try {
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'late_sandbox_reply',
+ name: 'edit_file',
+ args: { path: '/mnt/data/a.txt', old_text: 'a', new_text: 'b' },
+ },
+ ]);
+ expect(result.status).toBe('error');
+ expect(result.errorMessage).toContain('timed out');
+ expect(writeSandboxFile).not.toHaveBeenCalled();
+ } finally {
+ clock.mockRestore();
+ }
+ });
+
+ it.each(['pre-write', 'in-flight'])(
+ 'preserves %s sandbox edit cancellation as an abort',
+ async (stage) => {
+ const controller = new AbortController();
+ const throwIfAborted = controller.signal.throwIfAborted.bind(controller.signal);
+ let checks = 0;
+ const guard = jest.spyOn(controller.signal, 'throwIfAborted').mockImplementation(() => {
+ if (++checks === 3 && stage === 'pre-write') controller.abort();
+ throwIfAborted();
+ });
+ const writeSandboxFile = jest.fn(async () => {
+ controller.abort();
+ throw controller.signal.reason;
+ });
+ const warn = jest.spyOn(logger, 'warn');
+ const debug = jest.spyOn(logger, 'debug');
+ const handler = makeSandboxAuthoringHandler({
+ runSignal: controller.signal,
+ readSandboxFile: jest.fn(async () => ({ content: 'ax' })),
+ writeSandboxFile,
+ });
+ try {
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'cancel_at_write',
+ name: 'edit_file',
+ args: { path: '/mnt/data/a.txt', old_text: 'a', new_text: 'b' },
+ },
+ ]);
+ expect(result.status).toBe('error');
+ expect(result.errorMessage).not.toContain('Error writing');
+ expect(debug).toHaveBeenCalledWith(
+ '[ON_TOOL_EXECUTE] Tool edit_file cancelled by run abort',
+ expect.any(Object),
+ );
+ expect(warn).not.toHaveBeenCalledWith(
+ '[file_authoring] Sandbox write failed',
+ expect.any(Object),
+ );
+ expect(writeSandboxFile).toHaveBeenCalledTimes(stage === 'pre-write' ? 0 : 1);
+ expect(checks).toBe(3);
+ expect(result.artifact).toBeUndefined();
+ } finally {
+ guard.mockRestore();
+ warn.mockRestore();
+ debug.mockRestore();
+ }
+ },
+ );
+
+ it('supports an ordinary exact sandbox edit at the authoring size limit with omitted limits', async () => {
+ const content =
+ 'start\n' + ('x'.repeat(1023) + '\n').repeat(10239) + 'x'.repeat(1014) + '\nend';
+ expect(Buffer.byteLength(content)).toBe(10 * 1024 * 1024);
+ const writeSandboxFile = jest.fn(async (_params: { content: string }) => ({
+ stdout: 'written',
+ }));
+ const handler = makeSandboxAuthoringHandler({
+ readSandboxFile: jest.fn(async () => ({ content })),
+ writeSandboxFile,
+ });
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'authoring_limit',
+ name: 'edit_file',
+ args: { path: '/mnt/data/large.txt', old_text: 'start', new_text: 'begin' },
+ },
+ ]);
+ expect(result.status).toBe('success');
+ expect(writeSandboxFile).toHaveBeenCalledTimes(1);
+ expect(writeSandboxFile.mock.calls[0][0].content.startsWith('begin\n')).toBe(true);
+ expect(Buffer.byteLength(writeSandboxFile.mock.calls[0][0].content)).toBe(10 * 1024 * 1024);
+ });
+
+ it('persists one permitted full-context sandbox replacement with omitted limits', async () => {
+ const content =
+ 'start\n' + ('x'.repeat(1023) + '\n').repeat(10239) + 'x'.repeat(1014) + '\nend';
+ const replacement = 'begin' + content.slice(5);
+ const writeSandboxFile = jest.fn(async (_params: { content: string }) => ({
+ stdout: 'written',
+ }));
+ const handler = makeSandboxAuthoringHandler({
+ readSandboxFile: jest.fn(async () => ({ content })),
+ writeSandboxFile,
+ });
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'full_context',
+ name: 'edit_file',
+ args: { path: '/mnt/data/large.txt', old_text: content, new_text: replacement },
+ },
+ ]);
+ expect(result.status).toBe('success');
+ expect(writeSandboxFile).toHaveBeenCalledTimes(1);
+ expect(writeSandboxFile.mock.calls[0][0].content).toBe(replacement);
+ });
+
+ it.each([false, true])(
+ 'sanitizes sandbox processing failures, asynchronous=%s',
+ async (asynchronous) => {
+ const writeSandboxFile = jest.fn();
+ const handler = makeSandboxAuthoringHandler({
+ readSandboxFile: jest.fn(async () => ({ content: 'ax' })),
+ writeSandboxFile,
+ });
+ const process = jest
+ .spyOn(hostEditProcessing, 'applyHostTextEdits')
+ .mockImplementationOnce(() => {
+ const error = new Error('PRIVATE-STARTUP /operator/absolute/edit-worker.cjs');
+ if (asynchronous) return Promise.reject(error);
+ throw error;
+ });
+ try {
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'failed_startup',
+ name: 'edit_file',
+ args: { path: '/mnt/data/a.txt', old_text: 'a', new_text: 'b' },
+ },
+ ]);
+ expect(result.errorMessage).toBe('File edit processing failed. Nothing was written.');
+ expect(JSON.stringify(result)).not.toContain('PRIVATE-STARTUP');
+ expect(writeSandboxFile).not.toHaveBeenCalled();
+ } finally {
+ process.mockRestore();
+ }
+ },
+ );
+
+ it('preserves host-controlled edit diagnostics', async () => {
+ const writeSandboxFile = jest.fn();
+ const handler = makeSandboxAuthoringHandler({
+ readSandboxFile: jest.fn(async () => ({ content: 'ax' })),
+ writeSandboxFile,
+ });
+ const process = jest
+ .spyOn(hostEditProcessing, 'applyHostTextEdits')
+ .mockRejectedValueOnce(
+ new HostEditError(
+ 'File edit occurrence budget exceeded; narrow the replacements. Nothing was written.',
+ ),
+ );
+ try {
+ const [result] = await invokeHandler(handler, [
+ {
+ id: 'safe_edit_error',
+ name: 'edit_file',
+ args: { path: '/mnt/data/a.txt', old_text: 'a', new_text: 'b' },
+ },
+ ]);
+ expect(result.errorMessage).toContain('occurrence budget exceeded');
+ expect(writeSandboxFile).not.toHaveBeenCalled();
+ } finally {
+ process.mockRestore();
+ }
+ });
+
it('creates a sandbox file when it does not already exist', async () => {
const readSandboxFile = jest.fn(async () => {
throw new Error('cat: /mnt/data/new.txt: No such file or directory');
diff --git a/packages/api/src/agents/handlers.ts b/packages/api/src/agents/handlers.ts
index bbb1643d7c..9bf6e6cff4 100644
--- a/packages/api/src/agents/handlers.ts
+++ b/packages/api/src/agents/handlers.ts
@@ -145,9 +145,11 @@ import { mergeCodeFilesIntoContext } from './codeFilesSession';
import { toolValidationFeedback } from './validationFeedback';
import { createSkillContentDigest } from './compatibility';
import { isMissingSandboxPathError } from '~/files/code';
+import { applyHostTextEdits } from './files/processing';
import { deleteSkillWithRetry } from '~/skills/cleanup';
import { resolveDownloadPath } from '~/storage/path';
import { parseFrontmatter } from '../skills/import';
+import { HostEditError } from './files/matching';
import { cleanCodeToolOutput } from './cleanup';
import { primeSkillFiles } from './skillFiles';
import { instrumentPtcToolMap } from './ptc';
@@ -1141,13 +1143,6 @@ type ParsedSkillAuthoringPath = {
displayPath: string;
};
-type MatchedRange = { index: number; length: number };
-
-type MatchStatus =
- | { status: 'matched'; index: number; length: number; strategy: string }
- | { status: 'none' }
- | { status: 'ambiguous'; strategy: string; count: number; matches: MatchedRange[] };
-
type LoadedSkillText =
| { status: 'loaded'; content: string; bytes: number; fileId?: string }
| { status: 'missing' }
@@ -1731,368 +1726,6 @@ function getAuthorInfo(req: ServerRequest): {
};
}
-/**
- * Ranges a whitespace-tolerant strategy collects before it stops looking. An
- * internal memory bound, not a policy: ambiguity only needs a second match, and
- * exact `replace_all` never collects ranges at all.
- */
-const MAX_EDIT_MATCHES = 10_000;
-
-/** Pieces buffered before they are flattened into one bounded output chunk. */
-const REPLACE_ALL_FLUSH_PIECES = 1_024;
-const REPLACE_ALL_FLUSH_CHARS = 16 * 1024;
-
-/**
- * `content.split(needle).join(replacement)` without one array entry per match: pieces are
- * flattened into chunks of bounded size, so memory tracks the output, not the match count.
- */
-function replaceAllExact(content: string, needle: string, replacement: string): string {
- const chunks: string[] = [];
- let pieces: string[] = [];
- let pendingChars = 0;
- const flush = () => {
- chunks.push(pieces.join(''));
- pieces = [];
- pendingChars = 0;
- };
- let cursor = 0;
- for (let index = content.indexOf(needle); index !== -1; index = content.indexOf(needle, cursor)) {
- pieces.push(content.slice(cursor, index), replacement);
- pendingChars += index - cursor + replacement.length;
- cursor = index + needle.length;
- if (pieces.length >= REPLACE_ALL_FLUSH_PIECES || pendingChars >= REPLACE_ALL_FLUSH_CHARS) {
- flush();
- }
- }
- pieces.push(content.slice(cursor));
- flush();
- return chunks.join('');
-}
-
-/** Non-overlapping exact occurrences, counted without retaining their positions. */
-function countExactMatches(content: string, needle: string): number {
- let count = 0;
- for (
- let index = content.indexOf(needle);
- index !== -1;
- index = content.indexOf(needle, index + needle.length)
- ) {
- count++;
- }
- return count;
-}
-
-function countExactOccurrences(content: string, needle: string): number[] {
- const indexes: number[] = [];
- let start = 0;
- while (start <= content.length && indexes.length <= MAX_EDIT_MATCHES) {
- const index = content.indexOf(needle, start);
- if (index === -1) {
- break;
- }
- indexes.push(index);
- start = index + Math.max(1, needle.length);
- }
- return indexes;
-}
-
-function findExactMatch(content: string, needle: string): MatchStatus {
- const matches = countExactOccurrences(content, needle);
- if (matches.length === 1) {
- return { status: 'matched', index: matches[0], length: needle.length, strategy: 'exact' };
- }
- if (matches.length > 1) {
- return {
- status: 'ambiguous',
- strategy: 'exact',
- count: matches.length,
- matches: matches.map((index) => ({ index, length: needle.length })),
- };
- }
- return { status: 'none' };
-}
-
-function lineStarts(content: string): number[] {
- const starts = [0];
- for (let i = 0; i < content.length; i++) {
- if (content[i] === '\n') {
- starts.push(i + 1);
- }
- }
- return starts;
-}
-
-function commonIndent(lines: string[]): number {
- const indents = lines
- .filter((line) => line.trim().length > 0)
- .map((line) => {
- const match = /^(\s*)/.exec(line);
- return match ? match[1].length : 0;
- });
- return indents.length > 0 ? Math.min(...indents) : 0;
-}
-
-function stripCommonIndent(text: string): string {
- const lines = text.split('\n');
- const indent = commonIndent(lines);
- if (indent === 0) {
- return text;
- }
- return lines.map((line) => line.slice(Math.min(indent, line.length))).join('\n');
-}
-
-function findLineWindowMatch(
- content: string,
- needle: string,
- strategy: 'line-trimmed' | 'indentation-flexible',
-): MatchStatus {
- const contentLines = content.split('\n');
- const needleLines = needle.split('\n');
- if (needleLines.length > contentLines.length) {
- return { status: 'none' };
- }
-
- const starts = lineStarts(content);
- const matches: Array<{ index: number; length: number }> = [];
- const addMatch = (startLine: number) => {
- const index = starts[startLine];
- const endLine = startLine + needleLines.length;
- const end = endLine < starts.length ? starts[endLine] - 1 : content.length;
- matches.push({ index, length: end - index });
- };
-
- if (strategy === 'line-trimmed') {
- // Intern normalized lines so KMP compares integer IDs, not overlapping strings.
- const ids = new Map<string, number>();
- const pattern = needleLines.map((line) => {
- const normalized = line.trimEnd();
- let id = ids.get(normalized);
- if (id == null) {
- id = ids.size;
- ids.set(normalized, id);
- }
- return id;
- });
- const prefixes = new Uint32Array(pattern.length);
- let matched = 0;
- for (let i = 1; i < pattern.length; i++) {
- while (matched > 0 && pattern[i] !== pattern[matched]) {
- matched = prefixes[matched - 1];
- }
- if (pattern[i] === pattern[matched]) matched++;
- prefixes[i] = matched;
- }
-
- matched = 0;
- for (let i = 0; i < contentLines.length && matches.length <= MAX_EDIT_MATCHES; i++) {
- const id = ids.get(contentLines[i].trimEnd());
- while (matched > 0 && id !== pattern[matched]) {
- matched = prefixes[matched - 1];
- }
- if (id === pattern[matched]) matched++;
- if (matched === pattern.length) {
- addMatch(i - pattern.length + 1);
- // Keep overlapping occurrences for ambiguity detection and replace_all.
- matched = prefixes[matched - 1];
- }
- }
- } else {
- // This fallback runs only after line-trimmed and whitespace-normalized miss.
- // Two nonblank needle lines imply at least two tokens: any indentation match
- // would already have matched whitespace-normalized. An all-blank needle would
- // already have matched line-trimmed. Only a single nonblank line remains.
- let anchor = -1;
- for (let i = 0; i < needleLines.length; i++) {
- if (needleLines[i].trim().length === 0) continue;
- if (anchor !== -1) return { status: 'none' };
- anchor = i;
- }
- if (anchor === -1) return { status: 'none' };
-
- const normalizedNeedle = stripCommonIndent(needle).split('\n');
- const nonblank = new Uint32Array(contentLines.length + 1);
- for (let i = 0; i < contentLines.length; i++) {
- nonblank[i + 1] = nonblank[i] + Number(contentLines[i].trim().length > 0);
- }
- for (let i = anchor; i < contentLines.length && matches.length <= MAX_EDIT_MATCHES; i++) {
- if (nonblank[i + 1] === nonblank[i]) continue;
- const start = i - anchor;
- const end = start + needleLines.length;
- if (end > contentLines.length) break;
- if (nonblank[end] - nonblank[start] !== 1) continue;
- const indent = contentLines[i].length - contentLines[i].trimStart().length;
- let matchesNeedle = true;
- // Eligible windows have one nonblank line at a fixed offset. Each file line
- // can belong to at most two of them, so these comparisons stay linear too.
- for (let j = 0; j < needleLines.length; j++) {
- if (contentLines[start + j].slice(indent) !== normalizedNeedle[j]) {
- matchesNeedle = false;
- break;
- }
- }
- if (matchesNeedle) addMatch(start);
- }
- }
-
- if (matches.length === 1) {
- return { status: 'matched', ...matches[0], strategy };
- }
- if (matches.length > 1) {
- return { status: 'ambiguous', strategy, count: matches.length, matches };
- }
- return { status: 'none' };
-}
-
-function escapeRegExp(value: string): string {
- return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function findWhitespaceNormalizedMatch(content: string, needle: string): MatchStatus {
- const tokens = needle.trim().split(/\s+/).filter(Boolean);
- if (tokens.length < 2) {
- return { status: 'none' };
- }
- const pattern = tokens.map(escapeRegExp).join('\\s+');
- const regex = new RegExp(pattern, 'g');
- const matches: Array<{ index: number; length: number }> = [];
- let match: RegExpExecArray | null;
- while (matches.length <= MAX_EDIT_MATCHES && (match = regex.exec(content)) != null) {
- matches.push({ index: match.index, length: match[0].length });
- if (match[0].length === 0) {
- regex.lastIndex += 1;
- }
- }
- if (matches.length === 1) {
- return { status: 'matched', ...matches[0], strategy: 'whitespace-normalized' };
- }
- if (matches.length > 1) {
- return {
- status: 'ambiguous',
- strategy: 'whitespace-normalized',
- count: matches.length,
- matches,
- };
- }
- return { status: 'none' };
-}
-
-function findReplacementMatch(content: string, needle: string): MatchStatus {
- const exact = findExactMatch(content, needle);
- if (exact.status !== 'none') {
- return exact;
- }
- const lineTrimmed = findLineWindowMatch(content, needle, 'line-trimmed');
- if (lineTrimmed.status !== 'none') {
- return lineTrimmed;
- }
- const whitespaceNormalized = findWhitespaceNormalizedMatch(content, needle);
- if (whitespaceNormalized.status !== 'none') {
- return whitespaceNormalized;
- }
- return findLineWindowMatch(content, needle, 'indentation-flexible');
-}
-
-/** Keeps the earliest of any overlapping matches so replacements never collide. */
-function nonOverlapping(matches: readonly MatchedRange[]): MatchedRange[] {
- const kept: MatchedRange[] = [];
- let end = -1;
- for (const match of [...matches].sort((a, b) => a.index - b.index)) {
- if (match.index < end) continue;
- kept.push(match);
- end = match.index + match.length;
- }
- return kept;
-}
-
-function describeMatchCount(count: number): string {
- return count > MAX_EDIT_MATCHES ? `more than ${MAX_EDIT_MATCHES}` : String(count);
-}
-
-/**
- * The size `replace_all` would produce, computed before any replacement text is
- * built so an oversized result is refused without allocating it.
- */
-function projectedReplaceAllBytes(
- content: string,
- matches: readonly MatchedRange[],
- text: string,
-): number {
- const replacementBytes = Buffer.byteLength(text, 'utf8');
- let bytes = Buffer.byteLength(content, 'utf8');
- for (const match of matches) {
- bytes +=
- replacementBytes -
- Buffer.byteLength(content.slice(match.index, match.index + match.length), 'utf8');
- }
- return bytes;
-}
-
-function replaceMatches(content: string, matches: readonly MatchedRange[], text: string): string {
- let result = '';
- let cursor = 0;
- for (const match of matches) {
- result += content.slice(cursor, match.index) + text;
- cursor = match.index + match.length;
- }
- return result + content.slice(cursor);
-}
-
-function applyTextEdits(
- content: string,
- edits: TextEdit[],
-): { content: string; strategies: string[] } {
- let working = content;
- const strategies: string[] = [];
-
- for (const edit of edits) {
- const exactCount = edit.replace_all === true ? countExactMatches(working, edit.old_text) : 0;
- if (exactCount > 0) {
- const projectedBytes =
- Buffer.byteLength(working, 'utf8') +
- exactCount *
- (Buffer.byteLength(edit.new_text, 'utf8') - Buffer.byteLength(edit.old_text, 'utf8'));
- if (projectedBytes > MAX_AUTHORING_BYTES) {
- throw new Error(
- `replace_all would make the file larger than ${MAX_AUTHORING_BYTES} bytes; nothing was written.`,
- );
- }
- working = replaceAllExact(working, edit.old_text, edit.new_text);
- strategies.push(exactCount > 1 ? `exact x${exactCount}` : 'exact');
- continue;
- }
- const match = findReplacementMatch(working, edit.old_text);
- if (match.status === 'none') {
- throw new Error('old_text did not match the file content.');
- }
- if (match.status === 'ambiguous' && edit.replace_all !== true) {
- throw new Error(
- `old_text matched ${describeMatchCount(match.count)} locations with ${match.strategy}; make it unique or set replace_all before retrying.`,
- );
- }
- if (match.status === 'ambiguous') {
- if (match.count > MAX_EDIT_MATCHES) {
- throw new Error(
- `replace_all with whitespace-tolerant matching is limited to ${MAX_EDIT_MATCHES} locations, and old_text matched more; copy the exact text or narrow old_text before retrying.`,
- );
- }
- const matches = nonOverlapping(match.matches);
- if (projectedReplaceAllBytes(working, matches, edit.new_text) > MAX_AUTHORING_BYTES) {
- throw new Error(
- `replace_all would make the file larger than ${MAX_AUTHORING_BYTES} bytes; nothing was written.`,
- );
- }
- working = replaceMatches(working, matches, edit.new_text);
- strategies.push(`${match.strategy} x${matches.length}`);
- continue;
- }
- working =
- working.slice(0, match.index) + edit.new_text + working.slice(match.index + match.length);
- strategies.push(match.strategy);
- }
-
- return { content: working, strategies };
-}
-
function formatRange(start: number, count: number): string {
return count === 1 ? String(start) : `${start},${count}`;
}
@@ -3204,6 +2837,7 @@ async function writeSandboxTextForAuthoring({
created,
sandboxContext,
codeExecutionContext,
+ signal,
}: {
tc: ToolCallRequest;
options: ToolExecuteOptions;
@@ -3214,6 +2848,7 @@ async function writeSandboxTextForAuthoring({
created: boolean;
sandboxContext?: SandboxSessionContext;
codeExecutionContext?: CodeExecutionContext;
+ signal?: AbortSignal;
}): AuthoringResult {
if (!options.writeSandboxFile) {
return errorResult(
@@ -3236,6 +2871,7 @@ async function writeSandboxTextForAuthoring({
}
const ctx = sandboxSessionContext(tc, sandboxContext);
let writeResult: Awaited<ReturnType<NonNullable<ToolExecuteOptions['writeSandboxFile']>>>;
+ signal?.throwIfAborted();
try {
writeResult = await options.writeSandboxFile({
file_path: filePath,
@@ -3246,6 +2882,7 @@ async function writeSandboxTextForAuthoring({
...(req ? { req } : {}),
});
} catch (error) {
+ if (signal?.aborted === true && isAbortError(error)) throw error;
const message = getThrownValueMessage(error);
logger.warn('[file_authoring] Sandbox write failed', getSafeErrorMetadata(error));
return errorResult(
@@ -3887,6 +3524,7 @@ async function writeSkillMd({
skill,
skillName,
content,
+ signal,
}: {
tc: ToolCallRequest;
options: ToolExecuteOptions;
@@ -3896,6 +3534,7 @@ async function writeSkillMd({
skill: AuthoringSkill | null;
skillName: string;
content: string;
+ signal?: AbortSignal;
}): AuthoringResult {
const normalized = normalizeSkillMdContent(content, skillName);
if (normalized.status === 'error') {
@@ -4015,6 +3654,7 @@ async function writeSkillMd({
) {
diff = '';
}
+ signal?.throwIfAborted();
const result = await options.updateSkill({
id: skill._id.toString(),
expectedVersion: skill.version,
@@ -4067,6 +3707,7 @@ async function writeBundledSkillFile({
oldContent,
fileId,
created,
+ signal,
}: {
tc: ToolCallRequest;
options: ToolExecuteOptions;
@@ -4078,6 +3719,7 @@ async function writeBundledSkillFile({
oldContent?: string;
fileId?: string;
created: boolean;
+ signal?: AbortSignal;
}): AuthoringResult {
const editDenied = await ensureCanEditSkill(tc, options, req, skill._id);
if (editDenied) {
@@ -4132,6 +3774,7 @@ async function writeBundledSkillFile({
}
try {
+ signal?.throwIfAborted();
await options.saveSkillFileContent({
req,
skillId: skill._id,
@@ -4531,6 +4174,12 @@ async function handleSandboxCreateFileCall({
});
}
+function hostEditFailure(tc: ToolCallRequest, error: unknown): ToolExecuteResult {
+ if (error instanceof HostEditError) return errorResult(tc, error.message);
+ logger.warn('[file_authoring] Host edit processing failed', getSafeErrorMetadata(error));
+ return errorResult(tc, 'File edit processing failed. Nothing was written.');
+}
+
async function handleSandboxEditFileCall({
tc,
options,
@@ -4583,10 +4232,17 @@ async function handleSandboxEditFileCall({
let edited: { content: string; strategies: string[] };
try {
- edited = applyTextEdits(current.content, edits);
+ edited = await applyHostTextEdits(
+ current.content,
+ edits,
+ req?.config?.endpoints?.agents?.hostFileEdits,
+ signal,
+ );
} catch (error) {
- return errorResult(tc, error instanceof Error ? error.message : 'Failed to edit file');
+ if (signal?.aborted) throw error;
+ return hostEditFailure(tc, error);
}
+ signal?.throwIfAborted();
if (Buffer.byteLength(edited.content, 'utf8') > MAX_AUTHORING_BYTES) {
return errorResult(tc, `edited content exceeds ${MAX_AUTHORING_BYTES} byte limit`);
}
@@ -4598,6 +4254,7 @@ async function handleSandboxEditFileCall({
filePath,
content: edited.content,
oldContent: current.content,
+ signal,
created: false,
sandboxContext,
codeExecutionContext,
@@ -4816,10 +4473,17 @@ async function handleEditFileCall(
let edited: { content: string; strategies: string[] };
try {
- edited = applyTextEdits(current.content, edits);
+ edited = await applyHostTextEdits(
+ current.content,
+ edits,
+ req?.config?.endpoints?.agents?.hostFileEdits,
+ signal,
+ );
} catch (error) {
- return errorResult(tc, error instanceof Error ? error.message : 'Failed to edit file');
+ if (signal?.aborted) throw error;
+ return hostEditFailure(tc, error);
}
+ signal?.throwIfAborted();
if (Buffer.byteLength(edited.content, 'utf8') > MAX_AUTHORING_BYTES) {
return errorResult(tc, `edited content exceeds ${MAX_AUTHORING_BYTES} byte limit`);
}
@@ -4833,6 +4497,7 @@ async function handleEditFileCall(
skill,
skillName: parsed.skillName,
content: edited.content,
+ signal,
});
if (result.status === 'success') {
result.artifact = {
@@ -4853,6 +4518,7 @@ async function handleEditFileCall(
relativePath: parsed.relativePath,
displayPath: parsed.displayPath,
content: edited.content,
+ signal,
oldContent: current.content,
fileId: current.fileId,
created: false,
diff --git a/packages/api/src/agents/tools.ts b/packages/api/src/agents/tools.ts
index 598cf5747a..66f7319fcc 100644
--- a/packages/api/src/agents/tools.ts
+++ b/packages/api/src/agents/tools.ts
@@ -1,3 +1,4 @@
+import { HOST_FILE_EDIT_HARD_MAX_COUNT } from 'librechat-data-provider';
import {
Constants as AgentConstants,
CODE_EXECUTION_TOOLS,
@@ -827,6 +828,7 @@ const SKILL_EDIT_FILE_PARAMETERS: LCTool['parameters'] = Object.freeze({
},
edits: {
type: 'array',
+ maxItems: HOST_FILE_EDIT_HARD_MAX_COUNT,
description:
'Optional batch of replacements. Each old_text must match exactly once unless its replace_all is true.',
items: {
@@ -864,6 +866,7 @@ const CODE_EDIT_FILE_PARAMETERS: LCTool['parameters'] = Object.freeze({
},
edits: {
type: 'array',
+ maxItems: HOST_FILE_EDIT_HARD_MAX_COUNT,
description:
'Optional batch of replacements. Each old_text must match exactly once unless its replace_all is true.',
items: {
diff --git a/packages/api/tsdown.config.mjs b/packages/api/tsdown.config.mjs
index b815bbd659..7865777e57 100644
--- a/packages/api/tsdown.config.mjs
+++ b/packages/api/tsdown.config.mjs
@@ -6,7 +6,12 @@ export default defineConfig({
// `src/telemetry/index.ts` barrel: oxc emits declarations flat into outDir keyed
// by source basename, so two `index.ts` entries would collide (index.d.cts +
// index2.d.cts). Distinct basenames yield stable `index.*` / `telemetry.*` output.
- entry: ['src/index.ts', 'src/telemetry.ts', 'src/credentials.ts'],
+ entry: [
+ 'src/index.ts',
+ 'src/telemetry.ts',
+ 'src/credentials.ts',
+ 'src/agents/files/edit-worker.ts',
+ ],
format: ['cjs'],
platform: 'node',
dts: { oxc: true },
diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.ts
index 8c06a6a0dc..e8e2a15e5b 100644
--- a/packages/data-provider/src/config.spec.ts
+++ b/packages/data-provider/src/config.spec.ts
@@ -42,6 +42,32 @@ const endpointsConfig: TEndpointsConfig = {
Gemini: { type: EModelEndpoint.custom, userProvide: false, order: 9999 },
};
+describe('host-side file edit limits', () => {
+ it('keeps configuration optional and resolves safe defaults when configured', () => {
+ expect(agentsEndpointSchema.parse({}).hostFileEdits).toBeUndefined();
+ expect(agentsEndpointSchema.parse({ hostFileEdits: {} }).hostFileEdits).toEqual({
+ maxEdits: 100,
+ maxWorkBytes: 67108864,
+ maxOccurrences: 100000,
+ timeoutMs: 2000,
+ maxConcurrent: 2,
+ });
+ });
+ it.each([
+ { maxEdits: 101 },
+ { maxEdits: 0 },
+ { maxWorkBytes: 0 },
+ { maxOccurrences: 1000001 },
+ { timeoutMs: 0 },
+ { timeoutMs: 10001 },
+ { maxConcurrent: 9 },
+ { maxConcurrent: 1.5 },
+ { ignored: true },
+ ])('rejects unsafe limits %p', (hostFileEdits) => {
+ expect(agentsEndpointSchema.safeParse({ hostFileEdits }).success).toBe(false);
+ });
+});
+
describe('authenticated 2FA management rate limits', () => {
it('accepts an account budget and defaults an empty configuration to seven requests', () => {
for (const [input, expected] of [
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 461d4dc481..e7a8f156fb 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -1395,6 +1395,31 @@ export const DEFAULT_MAX_PROVIDER_ERROR_CHARS = 2000;
export const DEFAULT_AGENT_MODEL_RESPONSE_BODY_TIMEOUT_MS = 900_000;
export const DEFAULT_AGENT_MODEL_RESPONSE_HEADERS_TIMEOUT_MS = 300_000;
+export const HOST_FILE_EDIT_HARD_MAX_COUNT = 100;
+
+/** Host-side skill/sandbox edit budgets. Attached workers retain their own limits. */
+export const hostFileEditLimitsSchema = z
+ .object({
+ maxEdits: z
+ .number()
+ .int()
+ .min(1)
+ .max(HOST_FILE_EDIT_HARD_MAX_COUNT)
+ .default(HOST_FILE_EDIT_HARD_MAX_COUNT),
+ maxWorkBytes: z
+ .number()
+ .int()
+ .min(1024)
+ .max(256 * 1024 * 1024)
+ .default(64 * 1024 * 1024),
+ maxOccurrences: z.number().int().min(1).max(1_000_000).default(100_000),
+ timeoutMs: z.number().int().min(100).max(10_000).default(2000),
+ maxConcurrent: z.number().int().min(1).max(8).default(2),
+ })
+ .strict();
+
+export type HostFileEditLimits = z.infer<typeof hostFileEditLimitsSchema>;
+
/** Server-side resource and recovery policy for ephemeral child activity. */
export const subagentActivityConfigSchema = z.object({
replayTtlMs: z.number().int().min(1_000).max(86_400_000).default(300_000),
@@ -1413,6 +1438,7 @@ export const agentsEndpointSchema = baseEndpointSchema
.merge(
z.object({
/* agents specific */
+ hostFileEdits: hostFileEditLimitsSchema.optional(),
/** Maximum provider error characters retained in unprotected terminal failures. */
maxProviderErrorChars: z
.number()