let resolveAutoLiveToolResultMaxChars: typeof import("./tool-result-truncation.js").resolveAutoLiveToolResultMaxChars;

let getToolResultTextLength: typeof import("./tool-result-truncation.js").getToolResultTextLength;

let truncateOversizedToolResultsInMessages: typeof import("./tool-result-truncation.js").truncateOversizedToolResultsInMessages;

let truncateOversizedToolResultsInRuntimeTranscript: typeof import("./tool-result-truncation.js").truncateOversizedToolResultsInRuntimeTranscript;

let truncateOversizedToolResultsInSession: typeof import("./tool-result-truncation.js").truncateOversizedToolResultsInSession;

let sessionLikelyHasOversizedToolResults: typeof import("./tool-result-truncation.js").sessionLikelyHasOversizedToolResults;

let estimateToolResultReductionPotential: typeof import("./tool-result-truncation.js").estimateToolResultReductionPotential;

resolveAutoLiveToolResultMaxChars,

getToolResultTextLength,

truncateOversizedToolResultsInMessages,

truncateOversizedToolResultsInRuntimeTranscript,

truncateOversizedToolResultsInSession,

sessionLikelyHasOversizedToolResults,

estimateToolResultReductionPotential,

});

describe("truncateOversizedToolResultsInSession", () => {

it("does not create session metadata for missing runtime transcripts", async () => {

const dir = await createTmpDir();

const storePath = path.join(dir, "sessions.json");

await fs.writeFile(storePath, "{}\n", "utf8");

const result = await truncateOversizedToolResultsInRuntimeTranscript({

scope: {

agentId: "main",

sessionId: "missing-session",

sessionKey: "agent:main:missing",

storePath,

},

contextWindowTokens: 100,

});

expect(result.truncated).toBe(false);

expect(await fs.readFile(storePath, "utf8")).toBe("{}\n");

});

it("readably truncates aggregate medium tool results in a session file", async () => {

// Persisted truncation rewrites JSONL directly and emits the transcript

// update event instead of reopening through SessionManager internals.

rewriteTranscriptEntriesInSessionManager,

rewriteTranscriptEntriesInState,

} from "./transcript-rewrite.js";

import {

resolveRuntimeTranscriptReadTarget,

type RuntimeTranscriptScope,

} from "./transcript-runtime-state.js";

/**

* Maximum share of the context window a single tool result should occupy.

}

/**

* Truncates oversized tool results for a runtime transcript scope.

*/

export async function truncateOversizedToolResultsInRuntimeTranscript(params: {

scope: RuntimeTranscriptScope;

contextWindowTokens: number;

maxCharsOverride?: number;

aggregateMaxCharsOverride?: number;

config?: SessionWriteLockAcquireTimeoutConfig;

}): Promise<{ truncated: boolean; truncatedCount: number; reason?: string }> {

let sessionLock: Awaited<ReturnType<typeof acquireSessionWriteLock>> | undefined;

try {

const target = await resolveRuntimeTranscriptReadTarget(params.scope);

sessionLock = await acquireSessionWriteLock({

sessionFile: target.sessionFile,

...resolveSessionWriteLockOptions(params.config),

});

const state = await readTranscriptFileState(target.sessionFile);

return await truncateOversizedToolResultsInTranscriptState({

state,

contextWindowTokens: params.contextWindowTokens,

maxCharsOverride: params.maxCharsOverride,

aggregateMaxCharsOverride: params.aggregateMaxCharsOverride,

sessionFile: target.sessionFile,

sessionId: target.sessionId,

sessionKey: target.sessionKey,

agentId: target.agentId,

config: params.config,

});

} catch (err) {

const errMsg = formatErrorMessage(err);

log.warn(`[tool-result-truncation] Failed to truncate: ${errMsg}`);

return { truncated: false, truncatedCount: 0, reason: errMsg };

} finally {

await sessionLock?.release();

}

}

/**

* Truncates a named transcript file artifact. Runtime callers should prefer

* truncateOversizedToolResultsInRuntimeTranscript with agent/session scope.

* Truncates a named transcript file artifact.

*/

export async function truncateOversizedToolResultsInSession(params: {

sessionFile: string;