@librechat/agents 3.2.41 → 3.2.43

package/src/tools/local/LocalCodingTools.ts

@@ -3,6 +3,7 @@ import { createTwoFilesPatch } from 'diff';
 import { tool } from '@langchain/core/tools';
 import type { DynamicStructuredTool } from '@langchain/core/tools';
 import type * as t from '@/types';
+import { isWorkspaceClientTimeoutError } from './workspaceFS';
 import {
   createLocalBashProgrammaticToolCallingTool,
   createLocalProgrammaticToolCallingTool,
@@ -294,8 +295,14 @@ async function revertStrictWrite(
     } else {
       await fs.unlink(path);
     }
-  } catch {
-    /* best-effort: caller still sees the original syntax error */
+  } catch (error) {
+    // A timed-out revert leaves the rejected write on disk — the caller would
+    // otherwise claim "reverted to pre-write state" while the bad bytes remain.
+    // Surface it; for other failures stay best-effort (caller sees the original
+    // syntax error).
+    if (isWorkspaceClientTimeoutError(error)) {
+      throw error;
+    }
   }
 }
 
@@ -538,7 +545,12 @@ export function createLocalWriteFileTool(
         before = decoded.text;
         encoding = decoded;
         existed = true;
-      } catch {
+      } catch (error) {
+        // A stalled-RPC timeout is NOT "file absent" — treating it as such would
+        // overwrite an existing file with fresh content. Surface it instead.
+        if (isWorkspaceClientTimeoutError(error)) {
+          throw error;
+        }
         existed = false;
       }
 
@@ -546,7 +558,21 @@ export function createLocalWriteFileTool(
       const finalText = encodeFile(input.content, encoding);
       await fs.writeFile(path, finalText, 'utf8');
 
-      const syntax = await maybeRunSyntaxCheck(path, config);
+      let syntax;
+      try {
+        syntax = await maybeRunSyntaxCheck(path, config);
+      } catch (error) {
+        // A validation-read timeout must still honor strict mode's revert
+        // contract: restore the pre-write state before surfacing (best-effort —
+        // the revert may itself time out on the same stalled container).
+        if (
+          isWorkspaceClientTimeoutError(error) &&
+          config.postEditSyntaxCheck === 'strict'
+        ) {
+          await revertStrictWrite(fs, path, existed, before, encoding);
+        }
+        throw error;
+      }
 
       const diff = existed
         ? summariseDiff(path, before, input.content)
@@ -642,7 +668,20 @@ export function createLocalEditFileTool(
       const finalText = encodeFile(next, encoding);
       await fs.writeFile(path, finalText, 'utf8');
 
-      const syntax = await maybeRunSyntaxCheck(path, config);
+      let syntax;
+      try {
+        syntax = await maybeRunSyntaxCheck(path, config);
+      } catch (error) {
+        // As in write_file: a validation-read timeout still triggers strict
+        // mode's revert (edit_file always operates on an existing file).
+        if (
+          isWorkspaceClientTimeoutError(error) &&
+          config.postEditSyntaxCheck === 'strict'
+        ) {
+          await revertStrictWrite(fs, path, true, original, encoding);
+        }
+        throw error;
+      }
 
       const diff = summariseDiff(path, original, next);
       const fuzzy = strategiesUsed.some((s) => s !== 'exact');
@@ -826,7 +865,12 @@ async function* walkFiles(
     let entries;
     try {
       entries = await fs.readdir(dir, { withFileTypes: true });
-    } catch {
+    } catch (error) {
+      // A stalled-RPC timeout must surface, not be silently skipped as an
+      // unreadable directory — that would corrupt search results ("no matches").
+      if (isWorkspaceClientTimeoutError(error)) {
+        throw error;
+      }
       continue;
     }
     for (const entry of entries) {
@@ -1009,7 +1053,12 @@ async function fallbackGrep(
     let stat;
     try {
       stat = await fs.stat(file);
-    } catch {
+    } catch (error) {
+      // A stalled-RPC timeout must surface, not be skipped — skipping a file can
+      // report "no matches" even when the (unreadable-due-to-stall) file matched.
+      if (isWorkspaceClientTimeoutError(error)) {
+        throw error;
+      }
       continue;
     }
     if (stat.size > FALLBACK_GREP_MAX_FILE_BYTES) {
@@ -1021,7 +1070,11 @@ async function fallbackGrep(
     let content;
     try {
       content = await fs.readFile(file, 'utf8');
-    } catch {
+    } catch (error) {
+      // As above: a client-timeout means a stalled read, not an unreadable file.
+      if (isWorkspaceClientTimeoutError(error)) {
+        throw error;
+      }
       continue;
     }
     if (content.includes('\0')) {

package/src/tools/local/__tests__/FileCheckpointer.test.ts

@@ -3,6 +3,10 @@ import { join } from 'path';
 import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'fs/promises';
 import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
 import { LocalFileCheckpointerImpl } from '../FileCheckpointer';
+import {
+  WorkspaceClientTimeoutError,
+  type WorkspaceFS,
+} from '../workspaceFS';
 
 /**
  * Pins the LocalFileCheckpointer's per-Run snapshot/rewind contract.
@@ -63,6 +67,44 @@ describe('LocalFileCheckpointerImpl', () => {
     await expect(stat(file)).rejects.toThrow();
   });
 
+  it('rethrows a client-timeout from stat instead of snapshotting as absent', async () => {
+    // A stalled stat() must NOT be recorded as "absent" — that would delete an
+    // existing file on rewind. The timeout has to surface.
+    const fs = {
+      stat: async () => {
+        throw new WorkspaceClientTimeoutError(
+          'cloudflare sandbox listFiles exceeded 6000ms client-side timeout'
+        );
+      },
+    } as unknown as WorkspaceFS;
+    const cp = new LocalFileCheckpointerImpl(32 * 1024 * 1024, fs);
+
+    await expect(cp.captureBeforeWrite('/workspace/a.txt')).rejects.toThrow(
+      /client-side timeout/
+    );
+    // Nothing was snapshotted, so rewind is a no-op (no spurious deletion).
+    expect(await cp.rewind()).toBe(0);
+  });
+
+  it('rewind rethrows a client-timeout from a restore write instead of claiming success', async () => {
+    // A stalled restore write leaves the bad bytes on disk — rewind must surface
+    // the timeout, not silently count the path as restored.
+    const fs = {
+      stat: async () => ({ isFile: () => true, size: 5 }),
+      readFile: async () => Buffer.from('orig\n'),
+      mkdir: async () => undefined,
+      writeFile: async () => {
+        throw new WorkspaceClientTimeoutError(
+          'cloudflare sandbox writeFile exceeded 6000ms client-side timeout'
+        );
+      },
+    } as unknown as WorkspaceFS;
+    const cp = new LocalFileCheckpointerImpl(32 * 1024 * 1024, fs);
+
+    await cp.captureBeforeWrite('/workspace/a.txt'); // snapshots 'present'
+    await expect(cp.rewind()).rejects.toThrow(/client-side timeout/);
+  });
+
   it('rewinds across multiple files in a single pass', async () => {
     const a = join(dir, 'multi-a.txt');
     const b = join(dir, 'multi-b.txt');

package/src/tools/local/syntaxCheck.ts

@@ -18,6 +18,7 @@
 
 import { extname } from 'path';
 import type * as t from '@/types';
+import { isWorkspaceClientTimeoutError } from './workspaceFS';
 import {
   getSpawn,
   getWorkspaceFS,
@@ -168,7 +169,13 @@ const jsonCheck: SyntaxChecker = async (path, config) => {
   // file → catch returns undefined → ok: true) or read a different
   // file with the same absolute path. Codex P1 #24.
   const fs = getWorkspaceFS(config);
-  const raw = await fs.readFile(path, 'utf8').catch(() => undefined);
+  const raw = await fs.readFile(path, 'utf8').catch((error) => {
+    // A stalled read must not pass the syntax gate as ok:true — surface it.
+    if (isWorkspaceClientTimeoutError(error)) {
+      throw error;
+    }
+    return undefined;
+  });
   if (raw == null) return { ok: true };
   try {
     JSON.parse(raw);
@@ -237,7 +244,12 @@ export async function runPostEditSyntaxCheck(
       };
     }
     return result;
-  } catch {
+  } catch (error) {
+    // Don't swallow a stalled-RPC timeout as "no checker outcome" (which would
+    // let the write through without a real syntax gate) — surface it.
+    if (isWorkspaceClientTimeoutError(error)) {
+      throw error;
+    }
     return null;
   }
 }

package/src/tools/local/workspaceFS.ts

@@ -39,6 +39,33 @@ export type ReaddirEntry = {
   isSymbolicLink(): boolean;
 };
 
+/**
+ * Thrown when a {@link WorkspaceFS} operation is abandoned by a client-side
+ * backstop timeout (a stalled remote/sandbox RPC that never returned). This is
+ * DISTINCT from "file not found": callers that catch generic FS failures as
+ * absence — e.g. a pre-read before an overwrite, or a `stat` before snapshotting
+ * — MUST rethrow this so a stalled read isn't mistaken for a missing file (which
+ * would otherwise overwrite an existing file or snapshot it as absent).
+ */
+export class WorkspaceClientTimeoutError extends Error {
+  readonly code = 'WORKSPACE_CLIENT_TIMEOUT';
+  constructor(message: string) {
+    super(message);
+    this.name = 'WorkspaceClientTimeoutError';
+  }
+}
+
+export function isWorkspaceClientTimeoutError(
+  error: unknown
+): error is WorkspaceClientTimeoutError {
+  return (
+    error instanceof WorkspaceClientTimeoutError ||
+    (typeof error === 'object' &&
+      error !== null &&
+      (error as { code?: unknown }).code === 'WORKSPACE_CLIENT_TIMEOUT')
+  );
+}
+
 export interface WorkspaceFS {
   readFile(path: string, encoding: 'utf8'): Promise<string>;
   readFile(path: string): Promise<Buffer>;