protoagent 0.1.3 → 0.1.5

package/dist/tools/bash.js

@@ -114,7 +114,7 @@ async function isSafe(command) {
     }
     return validateCommandPaths(tokens);
 }
-export async function runBash(command, timeoutMs = 30_000, sessionId) {
+export async function runBash(command, timeoutMs = 30_000, sessionId, abortSignal) {
     // Layer 1: hard block
     if (isDangerous(command)) {
         return `Error: Command blocked for safety. "${command}" contains a dangerous pattern that cannot be executed.`;
@@ -139,6 +139,7 @@ export async function runBash(command, timeoutMs = 30_000, sessionId) {
         let stdout = '';
         let stderr = '';
         let timedOut = false;
+        let aborted = false;
         const child = spawn(command, [], {
             shell: true,
             cwd: process.cwd(),
@@ -147,13 +148,31 @@ export async function runBash(command, timeoutMs = 30_000, sessionId) {
         });
         child.stdout?.on('data', (data) => { stdout += data.toString(); });
         child.stderr?.on('data', (data) => { stderr += data.toString(); });
-        const timer = setTimeout(() => {
-            timedOut = true;
+        const terminateChild = () => {
             child.kill('SIGTERM');
             setTimeout(() => child.kill('SIGKILL'), 2000);
+        };
+        const onAbort = () => {
+            aborted = true;
+            terminateChild();
+        };
+        if (abortSignal?.aborted) {
+            onAbort();
+        }
+        else {
+            abortSignal?.addEventListener('abort', onAbort, { once: true });
+        }
+        const timer = setTimeout(() => {
+            timedOut = true;
+            terminateChild();
         }, timeoutMs);
         child.on('close', (code) => {
             clearTimeout(timer);
+            abortSignal?.removeEventListener('abort', onAbort);
+            if (aborted) {
+                resolve(`Command aborted by user.\nPartial stdout:\n${stdout.slice(0, 5000)}\nPartial stderr:\n${stderr.slice(0, 2000)}`);
+                return;
+            }
             if (timedOut) {
                 resolve(`Command timed out after ${timeoutMs / 1000}s.\nPartial stdout:\n${stdout.slice(0, 5000)}\nPartial stderr:\n${stderr.slice(0, 2000)}`);
                 return;
@@ -172,6 +191,7 @@ export async function runBash(command, timeoutMs = 30_000, sessionId) {
         });
         child.on('error', (err) => {
             clearTimeout(timer);
+            abortSignal?.removeEventListener('abort', onAbort);
             resolve(`Error executing command: ${err.message}`);
         });
     });

package/dist/tools/edit-file.js

@@ -1,10 +1,15 @@
 /**
  * edit_file tool — Find-and-replace in an existing file. Requires approval.
+ *
+ * Uses a fuzzy match cascade of 5 strategies to find the old_string,
+ * tolerating minor whitespace discrepancies from the model.
+ * Returns a unified diff on success so the model can verify its edit.
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { validatePath } from '../utils/path-validation.js';
 import { requestApproval } from '../utils/approval.js';
+import { assertReadBefore, recordRead } from '../utils/file-time.js';
 export const editFileTool = {
     type: 'function',
     function: {
@@ -27,32 +32,247 @@ export const editFileTool = {
         },
     },
 };
-export async function editFile(filePath, oldString, newString, expectedReplacements = 1, sessionId) {
-    if (oldString.length === 0) {
-        return 'Error: old_string cannot be empty.';
+/** Strategy 1: Exact verbatim match (current behavior). */
+const exactReplacer = {
+    name: 'exact',
+    findMatch(content, oldString) {
+        return content.includes(oldString) ? oldString : null;
+    },
+};
+/** Strategy 2: Per-line .trim() comparison — uses file's actual indentation. */
+const lineTrimmedReplacer = {
+    name: 'line-trimmed',
+    findMatch(content, oldString) {
+        const searchLines = oldString.split('\n').map(l => l.trim());
+        const contentLines = content.split('\n');
+        for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+            let match = true;
+            for (let j = 0; j < searchLines.length; j++) {
+                if (contentLines[i + j].trim() !== searchLines[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                // Return the actual lines from the file content
+                return contentLines.slice(i, i + searchLines.length).join('\n');
+            }
+        }
+        return null;
+    },
+};
+/** Strategy 3: Strip common leading indent from both before comparing. */
+const indentFlexReplacer = {
+    name: 'indent-flexible',
+    findMatch(content, oldString) {
+        const oldLines = oldString.split('\n');
+        const commonIndent = getCommonIndent(oldLines);
+        if (commonIndent === 0)
+            return null;
+        const stripped = oldLines.map(l => l.slice(commonIndent)).join('\n');
+        const contentLines = content.split('\n');
+        for (let i = 0; i <= contentLines.length - oldLines.length; i++) {
+            const fileSlice = contentLines.slice(i, i + oldLines.length);
+            const fileCommonIndent = getCommonIndent(fileSlice);
+            const fileStripped = fileSlice.map(l => l.slice(fileCommonIndent)).join('\n');
+            if (fileStripped === stripped) {
+                return fileSlice.join('\n');
+            }
+        }
+        return null;
+    },
+};
+/** Strategy 4: Collapse all whitespace runs to single space before comparing. */
+const whitespaceNormReplacer = {
+    name: 'whitespace-normalized',
+    findMatch(content, oldString) {
+        const normalize = (s) => s.replace(/\s+/g, ' ').trim();
+        const target = normalize(oldString);
+        if (!target)
+            return null;
+        const contentLines = content.split('\n');
+        const oldLineCount = oldString.split('\n').length;
+        // Slide a window of oldLineCount lines across the file
+        for (let i = 0; i <= contentLines.length - oldLineCount; i++) {
+            const window = contentLines.slice(i, i + oldLineCount).join('\n');
+            if (normalize(window) === target) {
+                return window;
+            }
+        }
+        return null;
+    },
+};
+/** Strategy 5: .trim() the entire oldString before searching. */
+const trimmedBoundaryReplacer = {
+    name: 'trimmed-boundary',
+    findMatch(content, oldString) {
+        const trimmed = oldString.trim();
+        if (trimmed === oldString)
+            return null; // no change from exact
+        return content.includes(trimmed) ? trimmed : null;
+    },
+};
+const STRATEGIES = [
+    exactReplacer,
+    lineTrimmedReplacer,
+    indentFlexReplacer,
+    whitespaceNormReplacer,
+    trimmedBoundaryReplacer,
+];
+function getCommonIndent(lines) {
+    let min = Infinity;
+    for (const line of lines) {
+        if (line.trim().length === 0)
+            continue; // skip blank lines
+        const indent = line.length - line.trimStart().length;
+        min = Math.min(min, indent);
     }
-    const validated = await validatePath(filePath);
-    const content = await fs.readFile(validated, 'utf8');
-    // Count occurrences
+    return min === Infinity ? 0 : min;
+}
+/**
+ * Count non-overlapping occurrences of `needle` in `haystack`.
+ */
+function countOccurrences(haystack, needle) {
     let count = 0;
     let idx = 0;
-    while ((idx = content.indexOf(oldString, idx)) !== -1) {
+    while ((idx = haystack.indexOf(needle, idx)) !== -1) {
         count++;
-        idx += oldString.length;
+        idx += needle.length;
     }
-    if (count === 0) {
-        return `Error: old_string not found in ${filePath}. Make sure you read the file first and use the exact text.`;
+    return count;
+}
+/**
+ * Try each strategy in order. Return the actual substring to replace,
+ * the strategy name used, and how many occurrences exist.
+ * Only accepts strategies that find exactly one match (unambiguous).
+ */
+function findWithCascade(content, oldString, expectedReplacements) {
+    for (const strategy of STRATEGIES) {
+        const actual = strategy.findMatch(content, oldString);
+        if (!actual)
+            continue;
+        const count = countOccurrences(content, actual);
+        if (count === expectedReplacements) {
+            return { actual, strategy: strategy.name, count };
+        }
+        // If count doesn't match expected, skip this strategy
+    }
+    return null;
+}
+// ─── Unified Diff ───
+function computeUnifiedDiff(oldContent, newContent, filePath) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    // Find changed regions
+    const hunks = [];
+    let i = 0;
+    let j = 0;
+    while (i < oldLines.length || j < newLines.length) {
+        // Skip matching lines
+        if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+            i++;
+            j++;
+            continue;
+        }
+        // Found a difference — collect the changed region
+        const oldStart = i;
+        const newStart = j;
+        const hunkOld = [];
+        const hunkNew = [];
+        // Collect differing lines
+        while (i < oldLines.length && j < newLines.length && oldLines[i] !== newLines[j]) {
+            hunkOld.push(oldLines[i]);
+            hunkNew.push(newLines[j]);
+            i++;
+            j++;
+        }
+        // Handle remaining lines in either side
+        while (i < oldLines.length && (j >= newLines.length || oldLines[i] !== newLines[j])) {
+            hunkOld.push(oldLines[i]);
+            i++;
+        }
+        while (j < newLines.length && (i >= oldLines.length || oldLines[i] !== newLines[j])) {
+            hunkNew.push(newLines[j]);
+            j++;
+        }
+        hunks.push({ oldStart, oldLines: hunkOld, newStart, newLines: hunkNew });
     }
-    if (count !== expectedReplacements) {
-        return `Error: found ${count} occurrence(s) of old_string, but expected ${expectedReplacements}. Be more specific or set expected_replacements=${count}.`;
+    if (hunks.length === 0)
+        return '';
+    // Build unified diff output with 2 lines of context
+    const CONTEXT = 2;
+    const diffLines = [
+        `--- a/${filePath}`,
+        `+++ b/${filePath}`,
+    ];
+    let totalChanged = 0;
+    for (const hunk of hunks) {
+        totalChanged += hunk.oldLines.length + hunk.newLines.length;
+        if (totalChanged > 50) {
+            // Add what we have so far, then truncate
+            break;
+        }
+        const ctxBefore = Math.max(0, hunk.oldStart - CONTEXT);
+        const ctxAfterOld = Math.min(oldLines.length, hunk.oldStart + hunk.oldLines.length + CONTEXT);
+        const ctxAfterNew = Math.min(newLines.length, hunk.newStart + hunk.newLines.length + CONTEXT);
+        const oldHunkSize = (hunk.oldStart - ctxBefore) + hunk.oldLines.length + (ctxAfterOld - hunk.oldStart - hunk.oldLines.length);
+        const newHunkSize = (hunk.newStart - ctxBefore) + hunk.newLines.length + (ctxAfterNew - hunk.newStart - hunk.newLines.length);
+        diffLines.push(`@@ -${ctxBefore + 1},${oldHunkSize} +${ctxBefore + 1},${newHunkSize} @@`);
+        // Context before
+        for (let k = ctxBefore; k < hunk.oldStart; k++) {
+            diffLines.push(` ${oldLines[k]}`);
+        }
+        // Removed lines
+        for (const line of hunk.oldLines) {
+            diffLines.push(`-${line}`);
+        }
+        // Added lines
+        for (const line of hunk.newLines) {
+            diffLines.push(`+${line}`);
+        }
+        // Context after
+        for (let k = hunk.oldStart + hunk.oldLines.length; k < ctxAfterOld; k++) {
+            diffLines.push(` ${oldLines[k]}`);
+        }
     }
+    if (totalChanged > 50) {
+        diffLines.push('... (truncated)');
+    }
+    return diffLines.join('\n');
+}
+// ─── Main editFile function ───
+export async function editFile(filePath, oldString, newString, expectedReplacements = 1, sessionId) {
+    if (oldString.length === 0) {
+        return 'Error: old_string cannot be empty.';
+    }
+    const validated = await validatePath(filePath);
+    // Staleness guard: must have read file before editing
+    if (sessionId) {
+        assertReadBefore(sessionId, validated);
+    }
+    const content = await fs.readFile(validated, 'utf8');
+    // Use fuzzy match cascade
+    const match = findWithCascade(content, oldString, expectedReplacements);
+    if (!match) {
+        // Check if we found it with wrong count
+        for (const strategy of STRATEGIES) {
+            const actual = strategy.findMatch(content, oldString);
+            if (actual) {
+                const count = countOccurrences(content, actual);
+                return `Error: found ${count} occurrence(s) of old_string (via ${strategy.name} match), but expected ${expectedReplacements}. Be more specific or set expected_replacements=${count}.`;
+            }
+        }
+        return `Error: old_string not found in ${filePath}. Strategies exhausted (exact, line-trimmed, indent-flexible, whitespace-normalized, trimmed-boundary). Re-read the file and try again.`;
+    }
+    const { actual, strategy, count } = match;
     // Request approval
     const oldPreview = oldString.length > 200 ? oldString.slice(0, 200) + '...' : oldString;
     const newPreview = newString.length > 200 ? newString.slice(0, 200) + '...' : newString;
+    const strategyNote = strategy !== 'exact' ? ` [matched via ${strategy}]` : '';
     const approved = await requestApproval({
         id: `edit-${Date.now()}`,
         type: 'file_edit',
-        description: `Edit file: ${filePath} (${count} replacement${count > 1 ? 's' : ''})`,
+        description: `Edit file: ${filePath} (${count} replacement${count > 1 ? 's' : ''})${strategyNote}`,
         detail: `Replace:\n${oldPreview}\n\nWith:\n${newPreview}`,
         sessionId,
         sessionScopeKey: `file_edit:${validated}`,
@@ -60,8 +280,8 @@ export async function editFile(filePath, oldString, newString, expectedReplaceme
     if (!approved) {
         return `Operation cancelled: edit to ${filePath} was rejected by user.`;
     }
-    // Perform replacement
-    const newContent = content.split(oldString).join(newString);
+    // Perform replacement using the actual matched string (not the model's version)
+    const newContent = content.split(actual).join(newString);
     const directory = path.dirname(validated);
     const tempPath = path.join(directory, `.protoagent-edit-${process.pid}-${Date.now()}-${path.basename(validated)}`);
     try {
@@ -71,5 +291,17 @@ export async function editFile(filePath, oldString, newString, expectedReplaceme
     finally {
         await fs.rm(tempPath, { force: true }).catch(() => undefined);
     }
-    return `Successfully edited ${filePath}: ${count} replacement(s) made.`;
+    // Re-read file after write (captures any formatter changes)
+    // Also record the read so subsequent edits don't fail the mtime check
+    const finalContent = await fs.readFile(validated, 'utf8');
+    if (sessionId) {
+        recordRead(sessionId, validated);
+    }
+    // Compute and return unified diff
+    const diff = computeUnifiedDiff(content, finalContent, filePath);
+    const header = `Successfully edited ${filePath}: ${count} replacement(s) made.`;
+    if (diff) {
+        return `${header}\n${diff}`;
+    }
+    return header;
 }

package/dist/tools/index.js

@@ -61,7 +61,7 @@ export async function handleToolCall(toolName, args, context = {}) {
     try {
         switch (toolName) {
             case 'read_file':
-                return await readFile(args.file_path, args.offset, args.limit);
+                return await readFile(args.file_path, args.offset, args.limit, context.sessionId);
             case 'write_file':
                 return await writeFile(args.file_path, args.content, context.sessionId);
             case 'edit_file':
@@ -71,7 +71,7 @@ export async function handleToolCall(toolName, args, context = {}) {
             case 'search_files':
                 return await searchFiles(args.search_term, args.directory_path, args.case_sensitive, args.file_extensions);
             case 'bash':
-                return await runBash(args.command, args.timeout_ms, context.sessionId);
+                return await runBash(args.command, args.timeout_ms, context.sessionId, context.abortSignal);
             case 'todo_read':
                 return readTodos(context.sessionId);
             case 'todo_write':

package/dist/tools/read-file.js

@@ -1,10 +1,15 @@
 /**
  * read_file tool — Read file contents with optional offset and limit.
+ *
+ * When a file is not found, suggests similar paths to help the model
+ * recover from typos without repeated failed attempts.
  */
 import fs from 'node:fs/promises';
 import { createReadStream } from 'node:fs';
 import readline from 'node:readline';
-import { validatePath } from '../utils/path-validation.js';
+import path from 'node:path';
+import { validatePath, getWorkingDirectory } from '../utils/path-validation.js';
+import { recordRead } from '../utils/file-time.js';
 export const readFileTool = {
     type: 'function',
     function: {
@@ -21,8 +26,85 @@ export const readFileTool = {
         },
     },
 };
-export async function readFile(filePath, offset = 0, limit = 2000) {
-    const validated = await validatePath(filePath);
+/**
+ * Find similar paths when a requested file doesn't exist.
+ * Walks from the repo root, matching segments case-insensitively.
+ */
+async function findSimilarPaths(requestedPath) {
+    const cwd = getWorkingDirectory();
+    const segments = requestedPath.split('/').filter(Boolean);
+    const MAX_DEPTH = 6;
+    const MAX_ENTRIES = 200;
+    const MAX_SUGGESTIONS = 3;
+    const candidates = [];
+    async function walkSegments(dir, segIndex, currentPath) {
+        if (segIndex >= segments.length || segIndex >= MAX_DEPTH || candidates.length >= MAX_SUGGESTIONS)
+            return;
+        const targetSegment = segments[segIndex].toLowerCase();
+        let entries;
+        try {
+            const dirEntries = await fs.readdir(dir, { withFileTypes: true });
+            entries = dirEntries
+                .slice(0, MAX_ENTRIES)
+                .map(e => e.name);
+        }
+        catch {
+            return;
+        }
+        const isLastSegment = segIndex === segments.length - 1;
+        for (const entry of entries) {
+            if (candidates.length >= MAX_SUGGESTIONS)
+                break;
+            const entryLower = entry.toLowerCase();
+            // Match if entry contains the target segment as a substring (case-insensitive)
+            if (!entryLower.includes(targetSegment) && !targetSegment.includes(entryLower))
+                continue;
+            const entryPath = path.join(currentPath, entry);
+            const fullPath = path.join(dir, entry);
+            if (isLastSegment) {
+                // Check if this file/dir actually exists
+                try {
+                    await fs.stat(fullPath);
+                    candidates.push(entryPath);
+                }
+                catch {
+                    // skip
+                }
+            }
+            else {
+                // Continue walking deeper
+                try {
+                    const stat = await fs.stat(fullPath);
+                    if (stat.isDirectory()) {
+                        await walkSegments(fullPath, segIndex + 1, entryPath);
+                    }
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+    }
+    await walkSegments(cwd, 0, '');
+    return candidates;
+}
+export async function readFile(filePath, offset = 0, limit = 2000, sessionId) {
+    let validated;
+    try {
+        validated = await validatePath(filePath);
+    }
+    catch (err) {
+        // If file not found, try to suggest similar paths
+        if (err.message?.includes('does not exist') || err.code === 'ENOENT') {
+            const suggestions = await findSimilarPaths(filePath);
+            let msg = `File not found: '${filePath}'`;
+            if (suggestions.length > 0) {
+                msg += '\nDid you mean one of these?\n' + suggestions.map(s => `  ${s}`).join('\n');
+            }
+            return msg;
+        }
+        throw err;
+    }
     const start = Math.max(0, offset);
     const maxLines = Math.max(0, limit);
     const lines = [];
@@ -59,6 +141,10 @@ export async function readFile(filePath, offset = 0, limit = 2000) {
         const truncated = line.length > 2000 ? line.slice(0, 2000) + '... (truncated)' : line;
         return `${lineNum} | ${truncated}`;
     });
+    // Record successful read for staleness tracking
+    if (sessionId) {
+        recordRead(sessionId, validated);
+    }
     const rangeLabel = lines.length === 0
         ? 'none'
         : `${Math.min(start + 1, totalLines)}-${end}`;

package/dist/tools/search-files.js

@@ -1,8 +1,13 @@
 /**
  * search_files tool — Recursive text search across files.
+ *
+ * Uses ripgrep (rg) when available for fast, .gitignore-aware searching.
+ * Falls back to a pure JS recursive directory walk if rg is not found.
  */
 import fs from 'node:fs/promises';
+import { statSync } from 'node:fs';
 import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { validatePath } from '../utils/path-validation.js';
 export const searchFilesTool = {
     type: 'function',
@@ -25,8 +30,95 @@ export const searchFilesTool = {
         },
     },
 };
+// Detect ripgrep availability at module load
+let hasRipgrep = false;
+try {
+    execFileSync('rg', ['--version'], { stdio: 'pipe' });
+    hasRipgrep = true;
+}
+catch {
+    // ripgrep not available, will use JS fallback
+}
+const MAX_RESULTS = 100;
 export async function searchFiles(searchTerm, directoryPath = '.', caseSensitive = true, fileExtensions) {
     const validated = await validatePath(directoryPath);
+    if (hasRipgrep) {
+        return searchWithRipgrep(searchTerm, validated, directoryPath, caseSensitive, fileExtensions);
+    }
+    return searchWithJs(searchTerm, validated, directoryPath, caseSensitive, fileExtensions);
+}
+// ─── Ripgrep implementation ───
+function searchWithRipgrep(searchTerm, validated, directoryPath, caseSensitive, fileExtensions) {
+    const args = [
+        '--line-number',
+        '--with-filename',
+        '--no-heading',
+        '--color=never',
+        '--max-count=1',
+        '--max-filesize=1M',
+    ];
+    if (!caseSensitive) {
+        args.push('--ignore-case');
+    }
+    if (fileExtensions && fileExtensions.length > 0) {
+        for (const ext of fileExtensions) {
+            // rg glob expects *.ext format
+            const globExt = ext.startsWith('.') ? `*${ext}` : `*.${ext}`;
+            args.push(`--glob=${globExt}`);
+        }
+    }
+    args.push('--regexp', searchTerm, validated);
+    try {
+        const output = execFileSync('rg', args, {
+            encoding: 'utf8',
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: 30_000,
+        });
+        const lines = output.trim().split('\n').filter(Boolean);
+        if (lines.length === 0) {
+            return `No matches found for "${searchTerm}" in ${directoryPath}`;
+        }
+        // Parse rg output and sort by mtime
+        const parsed = lines.slice(0, MAX_RESULTS).map(line => {
+            // rg output: filepath:linenum:content
+            const firstColon = line.indexOf(':');
+            const secondColon = line.indexOf(':', firstColon + 1);
+            const filePath = line.slice(0, firstColon);
+            const lineNum = line.slice(firstColon + 1, secondColon);
+            let content = line.slice(secondColon + 1).trim();
+            if (content.length > 500) {
+                content = content.slice(0, 500) + '... (truncated)';
+            }
+            const relativePath = path.relative(validated, filePath);
+            let mtime = 0;
+            try {
+                mtime = statSync(filePath).mtimeMs;
+            }
+            catch { /* ignore */ }
+            return { display: `${relativePath}:${lineNum}: ${content}`, mtime };
+        });
+        // Sort by mtime descending (most recently modified first)
+        parsed.sort((a, b) => b.mtime - a.mtime);
+        const results = parsed.map(r => r.display);
+        const suffix = lines.length > MAX_RESULTS ? `\n(results truncated at ${MAX_RESULTS})` : '';
+        return `Found ${results.length} match(es) for "${searchTerm}":\n${results.join('\n')}${suffix}`;
+    }
+    catch (err) {
+        // rg exits with code 1 if no matches found (not an error)
+        if (err.status === 1) {
+            return `No matches found for "${searchTerm}" in ${directoryPath}`;
+        }
+        // rg exits with code 2 for actual errors
+        if (err.status === 2) {
+            const msg = err.stderr?.toString() || err.message;
+            return `Error: ripgrep error: ${msg}`;
+        }
+        // Fall back to JS search on any other error
+        return `Error: ripgrep failed: ${err.message}`;
+    }
+}
+// ─── JS fallback implementation ───
+async function searchWithJs(searchTerm, validated, directoryPath, caseSensitive, fileExtensions) {
     const flags = caseSensitive ? 'g' : 'gi';
     let regex;
     try {
@@ -37,7 +129,6 @@ export async function searchFiles(searchTerm, directoryPath = '.', caseSensitive
         return `Error: invalid regex pattern "${searchTerm}": ${message}`;
     }
     const results = [];
-    const MAX_RESULTS = 100;
     async function search(dir) {
         if (results.length >= MAX_RESULTS)
             return;

package/dist/utils/compactor.js

@@ -43,7 +43,7 @@ export async function compactIfNeeded(client, model, messages, contextWindow, cu
         return messages;
     }
 }
-async function compactConversation(client, model, messages, _requestDefaults, sessionId) {
+async function compactConversation(client, model, messages, requestDefaults, sessionId) {
     // Separate system message, history to compress, and recent messages
     const systemMessage = messages[0];
     const recentMessages = messages.slice(-RECENT_MESSAGES_TO_KEEP);
@@ -69,6 +69,7 @@ async function compactConversation(client, model, messages, _requestDefaults, se
         },
     ];
     const response = await client.chat.completions.create({
+        ...requestDefaults,
         model,
         messages: compressionMessages,
         max_tokens: 2000,