responses-proxy 0.1.0

package/dist/rtk-layer.js

@@ -0,0 +1,483 @@
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+const DEFAULT_MAX_CHARS = 4_000;
+const DEFAULT_MAX_LINES = 120;
+const DEFAULT_DETECT_FORMAT = "auto";
+export function cloneRtkLayerPolicy(policy) {
+    if (!policy) {
+        return undefined;
+    }
+    return {
+        enabled: typeof policy.enabled === "boolean" ? policy.enabled : undefined,
+        toolOutputEnabled: typeof policy.toolOutputEnabled === "boolean" ? policy.toolOutputEnabled : undefined,
+        maxChars: typeof policy.maxChars === "number" && Number.isFinite(policy.maxChars) && policy.maxChars > 0
+            ? Math.round(policy.maxChars)
+            : undefined,
+        maxLines: typeof policy.maxLines === "number" && Number.isFinite(policy.maxLines) && policy.maxLines > 0
+            ? Math.round(policy.maxLines)
+            : undefined,
+        tailLines: typeof policy.tailLines === "number" &&
+            Number.isFinite(policy.tailLines) &&
+            policy.tailLines >= 0
+            ? Math.round(policy.tailLines)
+            : undefined,
+        tailChars: typeof policy.tailChars === "number" &&
+            Number.isFinite(policy.tailChars) &&
+            policy.tailChars >= 0
+            ? Math.round(policy.tailChars)
+            : undefined,
+        detectFormat: normalizeDetectFormat(policy.detectFormat),
+    };
+}
+export function parseRtkLayerPolicyInput(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    const policy = cloneRtkLayerPolicy({
+        enabled: coerceBoolean(record.enabled),
+        toolOutputEnabled: coerceBoolean(record.toolOutputEnabled ?? record.tool_output_enabled),
+        maxChars: coercePositiveInt(record.maxChars ?? record.max_chars),
+        maxLines: coercePositiveInt(record.maxLines ?? record.max_lines),
+        tailLines: coerceNonNegativeInt(record.tailLines ?? record.tail_lines),
+        tailChars: coerceNonNegativeInt(record.tailChars ?? record.tail_chars),
+        detectFormat: normalizeDetectFormat(record.detectFormat ?? record.detect_format),
+    });
+    if (!policy) {
+        return undefined;
+    }
+    if (policy.enabled === undefined &&
+        policy.toolOutputEnabled === undefined &&
+        policy.maxChars === undefined &&
+        policy.maxLines === undefined &&
+        policy.tailLines === undefined &&
+        policy.tailChars === undefined &&
+        policy.detectFormat === undefined) {
+        return undefined;
+    }
+    return policy;
+}
+export function resolveRtkLayerPolicy(base, providerPolicy, clientPolicy) {
+    const merged = {
+        ...base,
+        ...compactRtkLayerPolicy(cloneRtkLayerPolicy(providerPolicy)),
+        ...compactRtkLayerPolicy(cloneRtkLayerPolicy(clientPolicy)),
+    };
+    return {
+        enabled: merged.enabled,
+        toolOutputEnabled: merged.toolOutputEnabled,
+        maxChars: merged.maxChars ?? DEFAULT_MAX_CHARS,
+        maxLines: merged.maxLines ?? DEFAULT_MAX_LINES,
+        tailLines: merged.tailLines ?? 0,
+        tailChars: merged.tailChars,
+        detectFormat: normalizeDetectFormat(merged.detectFormat) ?? DEFAULT_DETECT_FORMAT,
+    };
+}
+function compactRtkLayerPolicy(policy) {
+    if (!policy) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(policy).filter(([, value]) => value !== undefined));
+}
+export function mergeRtkLayerPolicies(base, providerPolicy, clientPolicy) {
+    return resolveRtkLayerPolicy(base, providerPolicy, clientPolicy);
+}
+export function applyRtkLayer(body, options = {}) {
+    const stats = emptyStats(options.enabled === true);
+    if (!options.enabled || !options.toolOutputEnabled) {
+        return { body, stats };
+    }
+    let applied = false;
+    const nextBody = {
+        ...body,
+    };
+    if (Array.isArray(body.messages)) {
+        nextBody.messages = body.messages.map((message) => {
+            if (message.role !== "tool") {
+                return message;
+            }
+            const nextContent = transformMessageToolContent(message.content, stats, options);
+            if (nextContent === message.content) {
+                return message;
+            }
+            applied = true;
+            return {
+                ...message,
+                content: nextContent,
+            };
+        });
+    }
+    if (Array.isArray(body.input)) {
+        nextBody.input = body.input.map((item) => {
+            if (!isFunctionCallOutputItem(item)) {
+                return item;
+            }
+            const transformed = transformToolOutput(item.output, stats, options);
+            if (transformed === item.output) {
+                return item;
+            }
+            applied = true;
+            return {
+                ...item,
+                output: transformed,
+            };
+        });
+    }
+    stats.applied = applied;
+    stats.charsSaved = Math.max(0, stats.charsBefore - stats.charsAfter);
+    return {
+        body: applied ? nextBody : body,
+        stats,
+    };
+}
+function emptyStats(enabled) {
+    return {
+        enabled,
+        applied: false,
+        toolOutputsSeen: 0,
+        toolOutputsReduced: 0,
+        charsBefore: 0,
+        charsAfter: 0,
+        charsSaved: 0,
+    };
+}
+function transformMessageToolContent(content, stats, options) {
+    if (typeof content === "string") {
+        return transformToolOutput(content, stats, options);
+    }
+    if (!Array.isArray(content)) {
+        return content;
+    }
+    let changed = false;
+    const next = content.map((part) => {
+        if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string") {
+            return part;
+        }
+        const text = transformToolOutput(part.text, stats, options);
+        if (text !== part.text) {
+            changed = true;
+            return {
+                ...part,
+                text,
+            };
+        }
+        return part;
+    });
+    return changed ? next : content;
+}
+function transformToolOutput(raw, stats, options) {
+    stats.toolOutputsSeen += 1;
+    stats.charsBefore += raw.length;
+    const maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const normalized = canonicalizeToolOutput(raw);
+    const detectedFormat = detectToolOutputFormat(normalized, options.detectFormat);
+    const formatReady = detectedFormat === "json" ? prettifyJsonToolOutput(normalized) ?? normalized : normalized;
+    const reduced = clipToolOutput(formatReady, maxChars, maxLines, options.tailLines ?? 0, options.tailChars, detectedFormat);
+    stats.charsAfter += reduced.length;
+    if (reduced !== raw) {
+        stats.toolOutputsReduced += 1;
+    }
+    return reduced;
+}
+function canonicalizeToolOutput(raw) {
+    const lines = raw
+        .replace(/\r\n/g, "\n")
+        .replace(ANSI_PATTERN, "")
+        .split("\n")
+        .map((line) => line.replace(/[ \t]+$/g, ""))
+        .filter((line, index, all) => {
+        if (line.length > 0) {
+            return true;
+        }
+        return index > 0 && index < all.length - 1;
+    });
+    const deduped = [];
+    let previous;
+    for (const line of lines) {
+        if (line === previous && line.trim().length > 0) {
+            continue;
+        }
+        deduped.push(line);
+        previous = line;
+    }
+    return deduped.join("\n").trim();
+}
+function clipToolOutput(value, maxChars, maxLines, tailLines, tailChars, detectedFormat) {
+    const lines = value ? value.split("\n") : [];
+    if (lines.length <= maxLines && value.length <= maxChars) {
+        return value;
+    }
+    const safeTailLines = Math.max(0, Math.min(tailLines, maxLines > 1 ? maxLines - 1 : 0));
+    const initialHeadLineBudget = Math.max(1, maxLines - safeTailLines);
+    const headLines = lines.slice(0, initialHeadLineBudget);
+    const tailStartIndex = Math.max(initialHeadLineBudget, lines.length - safeTailLines);
+    const tail = safeTailLines > 0 ? lines.slice(tailStartIndex) : [];
+    const importantLines = extractImportantLines(lines, detectedFormat, initialHeadLineBudget, tailStartIndex, maxLines);
+    const marker = formatAwareTruncationMarker(detectedFormat);
+    const selectedLines = buildSelectedLines(headLines, importantLines, tail, marker);
+    let clipped = selectedLines.join("\n");
+    const visibleLines = countVisibleSourceLines(selectedLines, marker);
+    const hiddenLineCount = Math.max(0, lines.length - visibleLines);
+    const summary = ["", buildTruncationSummary(detectedFormat, hiddenLineCount, Math.max(0, value.length - Math.min(value.length, clipped.length)))].join("\n");
+    const summaryBudget = Math.max(0, maxChars - summary.length);
+    clipped = applySmartCharBudget(clipped, headLines.join("\n"), importantLines.join("\n"), tail.join("\n"), marker, summaryBudget, tailChars, detectedFormat);
+    const hiddenCharCount = Math.max(0, value.length - clipped.length);
+    const finalizedSummary = ["", buildTruncationSummary(detectedFormat, hiddenLineCount, hiddenCharCount)].join("\n");
+    const finalBudget = Math.max(0, maxChars - finalizedSummary.length);
+    const head = applySmartCharBudget(clipped, headLines.join("\n"), importantLines.join("\n"), tail.join("\n"), marker, finalBudget, tailChars, detectedFormat);
+    return `${head}${finalizedSummary}`.trim();
+}
+function applySmartCharBudget(fallbackClipped, headText, importantText, tailText, marker, availableChars, tailChars, detectedFormat) {
+    if (availableChars <= 0) {
+        return "";
+    }
+    if (!tailText && !importantText) {
+        return fallbackClipped.slice(0, availableChars).trimEnd();
+    }
+    const importantSeparatorBudget = importantText ? marker.length + 1 : 0;
+    const tailSeparatorBudget = tailText ? marker.length + 1 : 0;
+    const separatorBudget = importantSeparatorBudget + tailSeparatorBudget;
+    if (availableChars <= separatorBudget + 8) {
+        return fallbackClipped.slice(0, availableChars).trimEnd();
+    }
+    const autoTailRatio = detectedFormat === "stack"
+        ? 0.45
+        : detectedFormat === "command"
+            ? 0.38
+            : detectedFormat === "json"
+                ? 0.25
+                : 0.3;
+    const minTailChars = detectedFormat === "stack" ? 24 : detectedFormat === "json" ? 20 : 16;
+    const importantBudget = importantText.length > 0
+        ? Math.min(importantText.length, Math.max(24, Math.round(availableChars * (detectedFormat === "command" ? 0.34 : 0.18))))
+        : 0;
+    const desiredTailChars = typeof tailChars === "number" && tailChars >= 0
+        ? tailChars
+        : Math.round(availableChars * autoTailRatio);
+    const boundedTailChars = Math.max(0, Math.min(tailText.length, Math.max(minTailChars, desiredTailChars), Math.max(0, availableChars - separatorBudget - 16)));
+    const headBudget = Math.max(0, availableChars - separatorBudget - boundedTailChars - importantBudget);
+    const boundedHead = clipStartText(headText, headBudget);
+    const boundedImportant = detectedFormat === "command"
+        ? clipStartText(importantText, importantBudget)
+        : clipEndText(importantText, importantBudget);
+    const boundedTail = clipEndText(tailText, boundedTailChars);
+    let finalHead = boundedHead;
+    let finalImportant = boundedImportant;
+    let composite = buildBudgetComposite(finalHead, finalImportant, boundedTail, marker);
+    if (composite.length > availableChars && finalHead.length > 0) {
+        const overflow = composite.length - availableChars;
+        finalHead = clipStartText(finalHead, Math.max(0, finalHead.length - overflow));
+        composite = buildBudgetComposite(finalHead, finalImportant, boundedTail, marker);
+    }
+    if (composite.length > availableChars && finalImportant.length > 0) {
+        const overflow = composite.length - availableChars;
+        finalImportant =
+            detectedFormat === "command"
+                ? clipStartText(finalImportant, Math.max(0, finalImportant.length - overflow))
+                : clipEndText(finalImportant, Math.max(0, finalImportant.length - overflow));
+        composite = buildBudgetComposite(finalHead, finalImportant, boundedTail, marker);
+    }
+    return composite.length <= availableChars
+        ? composite
+        : composite.slice(0, availableChars).trimEnd();
+}
+function buildBudgetComposite(headText, importantText, tailText, marker) {
+    return [headText, importantText ? marker : "", importantText, tailText ? marker : "", tailText]
+        .filter(Boolean)
+        .join("\n");
+}
+function clipStartText(value, maxChars) {
+    if (maxChars <= 0) {
+        return "";
+    }
+    return value.length <= maxChars ? value : value.slice(0, maxChars).trimEnd();
+}
+function clipEndText(value, maxChars) {
+    if (maxChars <= 0) {
+        return "";
+    }
+    return value.length <= maxChars ? value : value.slice(Math.max(0, value.length - maxChars)).trimStart();
+}
+function extractImportantLines(lines, detectedFormat, headEndIndexExclusive, tailStartIndexInclusive, maxLines) {
+    if (detectedFormat !== "command" && detectedFormat !== "plain") {
+        return [];
+    }
+    const middle = lines.slice(headEndIndexExclusive, tailStartIndexInclusive);
+    if (middle.length === 0) {
+        return [];
+    }
+    const candidates = middle
+        .map((line, index) => ({
+        line,
+        index,
+        score: getOperationalLineImportance(line),
+    }))
+        .filter((entry) => entry.score > 0);
+    if (candidates.length === 0) {
+        return [];
+    }
+    const maxImportantLines = detectedFormat === "command"
+        ? Math.max(1, Math.min(2, Math.floor(maxLines / 2)))
+        : Math.max(1, Math.floor(maxLines / 3));
+    const highestScore = Math.max(...candidates.map((entry) => entry.score));
+    const prioritized = highestScore >= 3 ? candidates.filter((entry) => entry.score >= 3) : candidates;
+    const selected = prioritized
+        .sort((left, right) => right.score - left.score || left.index - right.index)
+        .slice(0, maxImportantLines)
+        .sort((left, right) => left.index - right.index)
+        .map((entry) => entry.line);
+    return selected;
+}
+function isImportantOperationalLine(line) {
+    return getOperationalLineImportance(line) > 0;
+}
+function getOperationalLineImportance(line) {
+    const normalized = line.trim().toLowerCase();
+    if (!normalized) {
+        return 0;
+    }
+    if (normalized.includes("fatal") ||
+        normalized.includes("error") ||
+        normalized.includes("exception") ||
+        normalized.includes("failed") ||
+        normalized.includes("failure")) {
+        return 3;
+    }
+    if (normalized.includes("timeout") ||
+        normalized.includes("timed out") ||
+        normalized.includes("exit code") ||
+        normalized.includes("status=") ||
+        normalized.includes("status code")) {
+        return 2;
+    }
+    if (normalized.includes("warn")) {
+        return 1;
+    }
+    return 0;
+}
+function buildSelectedLines(headLines, importantLines, tailLines, marker) {
+    const combined = [...headLines];
+    if (importantLines.length > 0) {
+        combined.push(marker, ...importantLines);
+    }
+    if (tailLines.length > 0) {
+        combined.push(marker, ...tailLines);
+    }
+    const deduped = [];
+    for (const line of combined) {
+        if (deduped[deduped.length - 1] === line) {
+            continue;
+        }
+        deduped.push(line);
+    }
+    return deduped;
+}
+function countVisibleSourceLines(selectedLines, marker) {
+    let markers = 0;
+    for (const line of selectedLines) {
+        if (line === marker) {
+            markers += 1;
+        }
+    }
+    return Math.max(0, selectedLines.length - markers);
+}
+function detectToolOutputFormat(value, detectFormat) {
+    const forced = normalizeDetectFormat(detectFormat);
+    if (forced && forced !== "auto") {
+        return forced;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "plain";
+    }
+    if (prettifyJsonToolOutput(trimmed)) {
+        return "json";
+    }
+    const lines = trimmed.split("\n");
+    const stackMatches = lines.filter((line) => /^\s*at\s+/.test(line) ||
+        /(Error|Exception|Traceback)/.test(line) ||
+        /:\d+:\d+/.test(line)).length;
+    if (stackMatches >= 2 || /^(?:\w*Error|\w*Exception|Traceback)/.test(lines[0] || "")) {
+        return "stack";
+    }
+    const commandMatches = lines.filter((line) => /^\s*(?:\$|>|\+|#)\s+/.test(line) ||
+        /^\s*(?:INFO|WARN|ERROR|DEBUG|TRACE)\b/.test(line) ||
+        /^\s*\[[A-Z]+\]/.test(line) ||
+        /^\s*\d{2}:\d{2}:\d{2}/.test(line) ||
+        /^\s*\d{4}-\d{2}-\d{2}[ T]/.test(line)).length;
+    if (commandMatches >= Math.max(2, Math.ceil(lines.length / 3))) {
+        return "command";
+    }
+    return "plain";
+}
+function prettifyJsonToolOutput(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== "object" || parsed === null) {
+            return undefined;
+        }
+        return JSON.stringify(parsed, null, 2);
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatAwareTruncationMarker(detectedFormat) {
+    switch (detectedFormat) {
+        case "json":
+            return '"... truncated json ..."';
+        case "stack":
+            return "... stack frames truncated ...";
+        case "command":
+            return "... log lines truncated ...";
+        default:
+            return "...";
+    }
+}
+function buildTruncationSummary(detectedFormat, hiddenLineCount, hiddenCharCount) {
+    return `[rtk trunc fmt=${detectedFormat} lines=${hiddenLineCount} chars=${hiddenCharCount}]`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunctionCallOutputItem(value) {
+    return isRecord(value) && value.type === "function_call_output" && typeof value.output === "string";
+}
+function coerceBoolean(value) {
+    if (value === true || value === "true" || value === 1 || value === "1") {
+        return true;
+    }
+    if (value === false || value === "false" || value === 0 || value === "0") {
+        return false;
+    }
+    return undefined;
+}
+function coercePositiveInt(value) {
+    const numeric = typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim()
+            ? Number(value)
+            : NaN;
+    return Number.isInteger(numeric) && numeric > 0 ? numeric : undefined;
+}
+function coerceNonNegativeInt(value) {
+    const numeric = typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim()
+            ? Number(value)
+            : NaN;
+    return Number.isInteger(numeric) && numeric >= 0 ? numeric : undefined;
+}
+function normalizeDetectFormat(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === "auto" ||
+        normalized === "plain" ||
+        normalized === "json" ||
+        normalized === "stack" ||
+        normalized === "command"
+        ? normalized
+        : undefined;
+}

package/dist/rtk-layer.test.js

@@ -0,0 +1,198 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { applyRtkLayer, resolveRtkLayerPolicy } from "./rtk-layer.js";
+test("rtk layer is inert when disabled", () => {
+    const body = {
+        model: "gpt-5.4",
+        messages: [
+            {
+                role: "user",
+                content: "hello",
+            },
+            {
+                role: "tool",
+                tool_call_id: "call_1",
+                content: "\u001b[32mok\u001b[0m\n\nsame\nsame\n",
+            },
+        ],
+    };
+    const result = applyRtkLayer(body, {
+        enabled: false,
+    });
+    assert.equal(result.body, body);
+    assert.equal(result.stats.applied, false);
+    assert.equal(result.stats.toolOutputsSeen, 0);
+});
+test("rtk layer canonicalizes and truncates tool message output deterministically", () => {
+    const body = {
+        model: "gpt-5.4",
+        messages: [
+            {
+                role: "user",
+                content: "check logs",
+            },
+            {
+                role: "tool",
+                tool_call_id: "call_1",
+                content: "\u001b[32mline-1\u001b[0m\r\n\r\nsame\r\nsame\r\nline-4\r\nline-5\r\nline-6",
+            },
+        ],
+    };
+    const result = applyRtkLayer(body, {
+        enabled: true,
+        toolOutputEnabled: true,
+        maxLines: 3,
+        maxChars: 80,
+    });
+    assert.equal(result.stats.applied, true);
+    assert.equal(result.stats.toolOutputsSeen, 1);
+    assert.equal(result.stats.toolOutputsReduced, 1);
+    const toolMessage = result.body.messages?.[1];
+    assert.equal(typeof toolMessage?.content, "string");
+    assert.match(toolMessage?.content, /\[rtk trunc fmt=plain/);
+    assert.equal((toolMessage?.content).includes("\u001b["), false);
+    assert.equal((toolMessage?.content).includes("same\nsame"), false);
+});
+test("rtk layer transforms direct function_call_output items without touching user input", () => {
+    const body = {
+        model: "gpt-5.4",
+        input: [
+            {
+                role: "user",
+                content: "keep this intact",
+            },
+            {
+                type: "function_call_output",
+                call_id: "call_1",
+                output: "a\nb\nc\nd\ne",
+            },
+        ],
+    };
+    const result = applyRtkLayer(body, {
+        enabled: true,
+        toolOutputEnabled: true,
+        maxLines: 2,
+        maxChars: 40,
+    });
+    assert.equal(result.body.input?.[0], body.input?.[0]);
+    assert.notEqual(result.body.input?.[1], body.input?.[1]);
+    assert.match(String((result.body.input?.[1]).output), /lines=3/);
+});
+test("rtk layer can preserve tail lines when truncating long tool output", () => {
+    const body = {
+        model: "gpt-5.4",
+        messages: [
+            {
+                role: "tool",
+                tool_call_id: "call_2",
+                content: "head-1\nhead-2\nmid-1\nmid-2\nerror-1\nerror-2",
+            },
+        ],
+    };
+    const result = applyRtkLayer(body, {
+        enabled: true,
+        toolOutputEnabled: true,
+        maxLines: 4,
+        maxChars: 120,
+        tailLines: 2,
+    });
+    assert.equal(result.stats.applied, true);
+    const toolMessage = result.body.messages?.[0];
+    assert.equal(typeof toolMessage?.content, "string");
+    assert.match(String(toolMessage?.content), /head-1/);
+    assert.match(String(toolMessage?.content), /\n\.\.\.\n/);
+    assert.match(String(toolMessage?.content), /error-1/);
+    assert.match(String(toolMessage?.content), /error-2/);
+    assert.equal(String(toolMessage?.content).includes("mid-1"), false);
+});
+test("rtk layer auto-detects and pretty-prints json before truncation", () => {
+    const body = {
+        model: "gpt-5.4",
+        messages: [
+            {
+                role: "tool",
+                tool_call_id: "call_json",
+                content: '{"root":{"items":[1,2,3],"meta":{"status":"ok","trace":"abc"}},"tail":{"done":true}}',
+            },
+        ],
+    };
+    const result = applyRtkLayer(body, {
+        enabled: true,
+        toolOutputEnabled: true,
+        maxLines: 6,
+        maxChars: 190,
+        tailLines: 3,
+        tailChars: 60,
+    });
+    const content = String(result.body.messages?.[0]?.content ?? "");
+    assert.match(content, /fmt=json/);
+    assert.match(content, /"root": \{/);
+    assert.match(content, /"done": true/);
+});
+test("rtk layer auto-detects stack traces and preserves the tail error frames", () => {
+    const body = {
+        model: "gpt-5.4",
+        messages: [
+            {
+                role: "tool",
+                tool_call_id: "call_stack",
+                content: "TypeError: failed\n    at first (/app/a.ts:1:1)\n    at second (/app/b.ts:2:2)\n    at third (/app/c.ts:3:3)\n    at final (/app/d.ts:4:4)",
+            },
+        ],
+    };
+    const result = applyRtkLayer(body, {
+        enabled: true,
+        toolOutputEnabled: true,
+        maxLines: 4,
+        maxChars: 140,
+        tailLines: 2,
+    });
+    const content = String(result.body.messages?.[0]?.content ?? "");
+    assert.match(content, /fmt=stack/);
+    assert.match(content, /stack frames truncated/);
+    assert.match(content, /final \(\/app\/d.ts:4:4/);
+});
+test("rtk layer preserves important command log lines from the middle segment", () => {
+    const body = {
+        model: "gpt-5.4",
+        messages: [
+            {
+                role: "tool",
+                tool_call_id: "call_cmd",
+                content: [
+                    "$ npm run build",
+                    "INFO compiling module a",
+                    "INFO compiling module b",
+                    "INFO compiling module c",
+                    "WARN retrying cache fetch",
+                    "INFO compiling module d",
+                    "ERROR request failed with status code 502",
+                    "INFO compiling module e",
+                    "INFO compiling module f",
+                    "build finished",
+                ].join("\n"),
+            },
+        ],
+    };
+    const result = applyRtkLayer(body, {
+        enabled: true,
+        toolOutputEnabled: true,
+        maxLines: 4,
+        maxChars: 180,
+        tailLines: 1,
+        detectFormat: "command",
+    });
+    const content = String(result.body.messages?.[0]?.content ?? "");
+    assert.match(content, /fmt=command/);
+    assert.match(content, /ERROR request failed with status code 502/);
+    assert.match(content, /build finished/);
+});
+test("rtk policy resolution prefers client override over provider default", () => {
+    const resolved = resolveRtkLayerPolicy({ enabled: true, toolOutputEnabled: true, maxChars: 4000, maxLines: 120, tailLines: 0, detectFormat: "auto" }, { maxChars: 2400, tailLines: 3 }, { maxLines: 60, detectFormat: "json" });
+    assert.equal(resolved.enabled, true);
+    assert.equal(resolved.toolOutputEnabled, true);
+    assert.equal(resolved.maxChars, 2400);
+    assert.equal(resolved.maxLines, 60);
+    assert.equal(resolved.tailLines, 3);
+    assert.equal(resolved.detectFormat, "json");
+});