@oh-my-pi/pi-coding-agent 16.2.5 → 16.2.6

package/src/config/model-discovery.ts

@@ -122,6 +122,12 @@ type OllamaDiscoveredModelMetadata = {
 type LlamaCppDiscoveredServerMetadata = {
 	contextWindow?: number;
 	input?: ("text" | "image")[];
+	maxTokens?: "contextWindow";
+};
+
+type LlamaCppDiscoveredModelRuntimeMetadata = {
+	contextWindow: number;
+	maxTokens: number;
 };
 
 type LlamaCppModelListEntry = {
@@ -143,6 +149,44 @@ function toPositiveNumberOrUndefined(value: unknown): number | undefined {
 	return undefined;
 }
 
+function isLlamaCppUnlimitedSentinel(value: unknown): boolean {
+	if (typeof value === "number") {
+		return value === -1;
+	}
+	if (typeof value === "string" && value.trim()) {
+		return Number(value) === -1;
+	}
+	return false;
+}
+
+/**
+ * llama.cpp `/props.default_generation_settings.params.{max_tokens,n_predict}`
+ * are per-request defaults the server applies when a client omits the field —
+ * clients can still raise them per call. Positive values therefore are NOT
+ * hard model caps; only the `-1` unlimited sentinel reliably tells us the
+ * server bounds generation by the runtime context window. Anything else
+ * leaves the discovery default in place.
+ */
+function extractLlamaCppMaxTokens(payload: Record<string, unknown>): "contextWindow" | undefined {
+	const generationSettings = payload.default_generation_settings;
+	const params = isRecord(generationSettings) ? generationSettings.params : undefined;
+	const candidates = [
+		isRecord(params) ? params.max_tokens : undefined,
+		isRecord(params) ? params.n_predict : undefined,
+		isRecord(generationSettings) ? generationSettings.max_tokens : undefined,
+		isRecord(generationSettings) ? generationSettings.n_predict : undefined,
+		payload.max_tokens,
+		payload.n_predict,
+	];
+	return candidates.some(isLlamaCppUnlimitedSentinel) ? "contextWindow" : undefined;
+}
+
+function resolveLlamaCppMaxTokens(contextWindow: number, maxTokens: "contextWindow" | undefined): number {
+	return maxTokens === "contextWindow"
+		? contextWindow
+		: Math.min(contextWindow, maxTokens ?? DISCOVERY_DEFAULT_MAX_TOKENS);
+}
+
 function extractOllamaRuntimeContextWindow(payload: Record<string, unknown>): number | undefined {
 	const parameters = payload.parameters;
 	if (typeof parameters !== "string") {
@@ -353,6 +397,7 @@ async function discoverLlamaCppServerMetadata(
 		}
 		return {
 			contextWindow: extractLlamaCppContextWindow(payload),
+			maxTokens: extractLlamaCppMaxTokens(payload),
 			input: extractLlamaCppInputCapabilities(payload),
 		};
 	} catch {
@@ -410,7 +455,7 @@ export async function discoverLlamaCppModels(
 				imageInputDecoder: "stb",
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 				contextWindow,
-				maxTokens: Math.min(contextWindow, DISCOVERY_DEFAULT_MAX_TOKENS),
+				maxTokens: resolveLlamaCppMaxTokens(contextWindow, serverMetadata?.maxTokens),
 				headers,
 				compat: {
 					supportsStore: false,
@@ -423,24 +468,37 @@ export async function discoverLlamaCppModels(
 	return discovered;
 }
 
-export async function discoverLlamaCppModelContextWindow(
+export async function discoverLlamaCppModelRuntimeMetadata(
 	model: Pick<Model<Api>, "provider" | "id" | "baseUrl" | "headers">,
 	ctx: DiscoveryContext,
-): Promise<number | undefined> {
+): Promise<LlamaCppDiscoveredModelRuntimeMetadata | undefined> {
 	const baseUrl = normalizeLlamaCppBaseUrl(model.baseUrl);
 	const modelsUrl = `${baseUrl}/models`;
 	const baseHeaders: Record<string, string> = { ...(model.headers ?? {}) };
 	const attempt = async (headers: Record<string, string>) => {
-		const response = await ctx.fetch(modelsUrl, {
-			headers,
-			signal: AbortSignal.timeout(250),
-		});
+		const [response, serverMetadata] = await Promise.all([
+			ctx.fetch(modelsUrl, {
+				headers,
+				signal: AbortSignal.timeout(250),
+			}),
+			discoverLlamaCppServerMetadata(ctx, baseUrl, headers),
+		]);
 		if (!response.ok) {
 			return undefined;
 		}
 		const entries = parseLlamaCppModelList(await response.json());
 		const entry = entries.find(entry => entry.id === model.id);
-		return entry?.runtimeContextWindow ?? entry?.trainingContextWindow;
+		if (!entry) {
+			return undefined;
+		}
+		const contextWindow = entry.runtimeContextWindow ?? serverMetadata?.contextWindow ?? entry.trainingContextWindow;
+		if (contextWindow === undefined) {
+			return undefined;
+		}
+		return {
+			contextWindow,
+			maxTokens: resolveLlamaCppMaxTokens(contextWindow, serverMetadata?.maxTokens),
+		};
 	};
 	try {
 		const apiKey = await ctx.getBearerApiKeyResolver(model.provider);

package/src/config/model-registry.ts

@@ -75,7 +75,7 @@ import {
 	DISCOVERY_DEFAULT_MAX_TOKENS,
 	type DiscoveryContext,
 	type DiscoveryProviderConfig,
-	discoverLlamaCppModelContextWindow,
+	discoverLlamaCppModelRuntimeMetadata,
 	discoverModelsByProviderType,
 	getImplicitOllamaBaseUrl,
 	getOllamaContextLengthOverride,
@@ -873,10 +873,11 @@ export class ModelRegistry {
 		if (!isLlamaCppDiscovery) {
 			return model;
 		}
-		const contextWindow = await discoverLlamaCppModelContextWindow(model, this.#nonResolvingDiscoveryContext());
-		if (contextWindow === undefined) {
+		const runtimeMetadata = await discoverLlamaCppModelRuntimeMetadata(model, this.#nonResolvingDiscoveryContext());
+		if (runtimeMetadata === undefined) {
 			return this.find(model.provider, model.id) ?? model;
 		}
+		const { contextWindow, maxTokens } = runtimeMetadata;
 		const current = this.find(model.provider, model.id) ?? model;
 		const override = this.#resolveLiveModelOverride(current);
 		const customModel = this.#resolveLiveCustomModelOverlay(current);
@@ -888,13 +889,19 @@ export class ModelRegistry {
 		) {
 			patch.contextWindow = contextWindow;
 		}
-		const maxTokens = Math.min(contextWindow, DISCOVERY_DEFAULT_MAX_TOKENS);
+		const effectiveContextWindow =
+			override?.contextWindow ??
+			customModel?.contextWindow ??
+			patch.contextWindow ??
+			current.contextWindow ??
+			contextWindow;
+		const effectiveMaxTokens = Math.min(maxTokens, effectiveContextWindow);
 		if (
 			override?.maxTokens === undefined &&
 			customModel?.maxTokens === undefined &&
-			current.maxTokens !== maxTokens
+			current.maxTokens !== effectiveMaxTokens
 		) {
-			patch.maxTokens = maxTokens;
+			patch.maxTokens = effectiveMaxTokens;
 		}
 		if (patch.contextWindow === undefined && patch.maxTokens === undefined) {
 			return current;

package/src/edit/hashline/execute.ts

@@ -27,6 +27,7 @@ import { ToolError } from "../../tools/tool-errors";
 import { generateDiffString } from "../diff";
 import { getFileSnapshotStore } from "../file-snapshot-store";
 import type { EditToolDetails, EditToolPerFileResult, LspBatchRequest } from "../renderer";
+import { pruneOversizedEditSnapshots } from "../snapshot-details";
 import { nativeBlockResolver } from "./block-resolver";
 import { HashlineFilesystem } from "./filesystem";
 import { hashPatchInput, NOOP_HARD_LIMIT, recordNoopEdit, resetNoopEdit } from "./noop-loop-guard";
@@ -114,17 +115,22 @@ function renderSection(
 	if (result.op === "delete") {
 		const toolResult: AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema> = {
 			content: [{ type: "text", text: `Deleted ${result.path}` }],
-			details: {
+			details: pruneOversizedEditSnapshots({
 				diff: "",
 				op: "delete",
 				path: result.path,
 				oldText: result.before,
 				meta: outputMeta().get(),
-			},
+			}),
 		};
 		return {
 			toolResult,
-			perFileResult: { path: result.path, diff: "", op: "delete", oldText: result.before },
+			perFileResult: pruneOversizedEditSnapshots({
+				path: result.path,
+				diff: "",
+				op: "delete",
+				oldText: result.before,
+			}),
 		};
 	}
 
@@ -161,7 +167,7 @@ function renderSection(
 					text: `${result.header}${blockBlock}${moveBlock}${previewBlock}${warningsBlock}`,
 				},
 			],
-			details: {
+			details: pruneOversizedEditSnapshots({
 				diff: diff.diff,
 				firstChangedLine,
 				diagnostics,
@@ -172,9 +178,9 @@ function renderSection(
 				oldText: result.before,
 				newText: result.after,
 				meta,
-			},
+			}),
 		},
-		perFileResult: {
+		perFileResult: pruneOversizedEditSnapshots({
 			path: result.moveDest ?? result.path,
 			diff: diff.diff,
 			firstChangedLine,
@@ -184,7 +190,7 @@ function renderSection(
 			sourcePath: result.moveDest ? sourcePath : undefined,
 			oldText: result.before,
 			newText: result.after,
-		},
+		}),
 	};
 }
 
@@ -263,10 +269,10 @@ export async function executeHashlineSingle(
 					.join("\n\n"),
 			},
 		],
-		details: {
+		details: pruneOversizedEditSnapshots({
 			diff: rendered.map(r => r.toolResult.details?.diff ?? "").join("\n"),
 			perFileResults: rendered.map(r => r.perFileResult),
-		},
+		}),
 	};
 }
 

package/src/edit/index.ts

@@ -25,6 +25,7 @@ import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
 import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
+import { pruneOversizedEditSnapshots } from "./snapshot-details";
 import { EDIT_MODE_STRATEGIES } from "./streaming";
 
 export * from "@oh-my-pi/hashline";
@@ -38,6 +39,7 @@ export * from "./modes/patch";
 export * from "./modes/replace";
 export * from "./normalize";
 export * from "./renderer";
+export * from "./snapshot-details";
 export * from "./streaming";
 
 type TInput =
@@ -158,6 +160,7 @@ async function executeApplyPatchPerFile(
 				meta: details?.meta,
 				oldText: details?.oldText,
 				newText: details?.newText,
+				snapshotsPruned: details?.snapshotsPruned,
 			});
 			const text = result.content?.find(c => c.type === "text")?.text ?? "";
 			if (text) contentTexts.push(text);
@@ -186,14 +189,14 @@ async function executeApplyPatchPerFile(
 
 	return {
 		content: [{ type: "text", text: contentTexts.join("\n") }],
-		details: {
+		details: pruneOversizedEditSnapshots({
 			diff: perFileResults
 				.map(r => r.diff)
 				.filter(Boolean)
 				.join("\n"),
 			firstChangedLine: perFileResults.find(r => r.firstChangedLine)?.firstChangedLine,
 			perFileResults,
-		},
+		}),
 	};
 }
 
@@ -216,6 +219,11 @@ async function executeSinglePathEntries(
 	let firstOldText: string | undefined;
 	let hasLastNewText = false;
 	let lastNewText: string | undefined;
+	// Any pruned child invalidates the aggregate snapshot: combining a kept
+	// first-entry oldText with a pruned next entry's newText (or vice-versa)
+	// would describe a transition the file never made. Suppress aggregate
+	// snapshots and stamp the marker so ACP/downstream can degrade cleanly.
+	let snapshotsPruned = false;
 
 	for (let i = 0; i < runs.length; i++) {
 		const isLast = i === runs.length - 1;
@@ -239,6 +247,7 @@ async function executeSinglePathEntries(
 				lastNewText = details.newText;
 				hasLastNewText = true;
 			}
+			if (details?.snapshotsPruned) snapshotsPruned = true;
 			const text = result.content?.find(c => c.type === "text")?.text ?? "";
 			if (text) contentTexts.push(text);
 		} catch (err) {
@@ -276,13 +285,17 @@ async function executeSinglePathEntries(
 
 	return {
 		content: [{ type: "text", text: contentTexts.join("\n") }],
-		details: {
+		details: pruneOversizedEditSnapshots({
 			diff: diffTexts.join("\n"),
 			firstChangedLine,
 			path: metadataPath ?? path,
-			...(hasFirstOldText ? { oldText: firstOldText } : {}),
-			...(hasLastNewText ? { newText: lastNewText } : {}),
-		},
+			...(snapshotsPruned
+				? { snapshotsPruned: true as const }
+				: {
+						...(hasFirstOldText ? { oldText: firstOldText } : {}),
+						...(hasLastNewText ? { newText: lastNewText } : {}),
+					}),
+		}),
 		// Any per-entry failure marks the aggregate result as an error so the
 		// renderer takes the error branch instead of falling through to the
 		// streaming-edit preview (which displays the *proposed* diff and looks

package/src/edit/modes/patch.ts

@@ -48,6 +48,7 @@ import {
 } from "../normalize";
 import { readEditFileText, serializeEditFileText } from "../read-file";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
+import { pruneOversizedEditSnapshots } from "../snapshot-details";
 import {
 	type ContextLineResult,
 	DEFAULT_FUZZY_THRESHOLD,
@@ -1894,7 +1895,7 @@ export async function executePatchSingle(
 
 	return {
 		content: [{ type: "text", text: resultText }],
-		details: {
+		details: pruneOversizedEditSnapshots({
 			diff: diffResult.diff,
 			// When the patch moves the file, anchor the diff to the destination
 			// path. ACP `ToolCallContent.diff.path` comes from this field, and
@@ -1909,6 +1910,6 @@ export async function executePatchSingle(
 			meta,
 			oldText,
 			newText,
-		},
+		}),
 	};
 }

package/src/edit/modes/replace.ts

@@ -24,6 +24,7 @@ import {
 } from "../normalize";
 import { readEditFileText, serializeEditFileText } from "../read-file";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
+import { pruneOversizedEditSnapshots } from "../snapshot-details";
 
 export interface FuzzyMatch {
 	actualText: string;
@@ -1123,7 +1124,7 @@ export async function executeReplaceSingle(
 
 	return {
 		content: [{ type: "text", text: resultText }],
-		details: {
+		details: pruneOversizedEditSnapshots({
 			diff: diffResult.diff,
 			path: absolutePath,
 			firstChangedLine: diffResult.firstChangedLine,
@@ -1131,6 +1132,6 @@ export async function executeReplaceSingle(
 			meta,
 			oldText: rawContent,
 			newText: finalContent,
-		},
+		}),
 	};
 }

package/src/edit/renderer.ts

@@ -70,6 +70,8 @@ export interface EditToolPerFileResult {
 	oldText?: string;
 	/** Source-of-truth content after the edit; `undefined` for delete operations. */
 	newText?: string;
+	/** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+	snapshotsPruned?: boolean;
 	/** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
 	sourcePath?: string;
 }
@@ -95,6 +97,8 @@ export interface EditToolDetails {
 	oldText?: string;
 	/** Source-of-truth content after the edit; `undefined` for delete operations. */
 	newText?: string;
+	/** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+	snapshotsPruned?: boolean;
 	/** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
 	sourcePath?: string;
 }

package/src/edit/snapshot-details.ts

@@ -0,0 +1,77 @@
+/**
+ * Bound the size of the `oldText` / `newText` snapshots that edit-tool results
+ * carry in `details`. These fields hold the full pre/post file content; for
+ * large files they balloon the per-turn JSONL line and the session file
+ * (300 KB+ each on the cases reported in #3786) without paying for any LLM
+ * context (provider serializers send only `content`, never `details`).
+ *
+ * Only consumer of the raw snapshots is the ACP event mapper, which builds a
+ * `diff` ToolCallContent for ACP clients (Zed). When the snapshots are pruned
+ * the mapper returns `undefined` for that file and the text content still
+ * flows — diff visualization degrades gracefully for over-threshold edits.
+ */
+
+import type { EditToolDetails, EditToolPerFileResult } from "./renderer";
+
+/**
+ * Combined `oldText` + `newText` character budget for a single edit-tool
+ * result. Applies both per-entry (one file at a time) and as an aggregate
+ * across `perFileResults` (so a many-small-files batch can't accumulate
+ * unbounded snapshot bytes — see #3787 review).
+ *
+ * Picked so typical code-file edits keep ACP diff visualization while
+ * pathological cases (large generated files, full-file rewrites, or
+ * many-file batches) drop the raw snapshots before they hit the
+ * session JSONL.
+ */
+export const MAX_EDIT_SNAPSHOT_TEXT_CHARS = 32_768;
+
+type WithSnapshot = { oldText?: string; newText?: string; snapshotsPruned?: boolean };
+
+function pruneSnapshot<T extends WithSnapshot>(details: T): T {
+	if ((details.oldText?.length ?? 0) + (details.newText?.length ?? 0) <= MAX_EDIT_SNAPSHOT_TEXT_CHARS) {
+		return details;
+	}
+	const { oldText: _old, newText: _new, ...rest } = details;
+	return { ...rest, snapshotsPruned: true } as T;
+}
+
+/**
+ * Walk `perFileResults` in order with a shared budget. Each per-entry payload
+ * is first capped individually by {@link pruneSnapshot}; if its kept bytes
+ * would push the running aggregate past the cap, strip and mark this entry
+ * too. Early entries get to keep their diff visualization; later entries in
+ * a large batch degrade to text-only.
+ */
+function capPerFileSnapshots<T extends WithSnapshot>(entries: T[]): T[] {
+	let remaining = MAX_EDIT_SNAPSHOT_TEXT_CHARS;
+	return entries.map(entry => {
+		const perEntry = pruneSnapshot(entry);
+		const kept = (perEntry.oldText?.length ?? 0) + (perEntry.newText?.length ?? 0);
+		if (kept === 0) return perEntry;
+		if (kept <= remaining) {
+			remaining -= kept;
+			return perEntry;
+		}
+		const { oldText: _old, newText: _new, ...rest } = perEntry;
+		return { ...rest, snapshotsPruned: true } as T;
+	});
+}
+
+/**
+ * Prune oversized `oldText` / `newText` from an edit-tool details payload,
+ * recursing into `perFileResults` when present. Per-file overload comes first
+ * so the more specific shape (required `path`) wins overload resolution at
+ * the per-file call sites.
+ */
+export function pruneOversizedEditSnapshots(details: EditToolPerFileResult): EditToolPerFileResult;
+export function pruneOversizedEditSnapshots(details: EditToolDetails): EditToolDetails;
+export function pruneOversizedEditSnapshots(
+	details: EditToolDetails | EditToolPerFileResult,
+): EditToolDetails | EditToolPerFileResult {
+	const pruned = pruneSnapshot(details);
+	if ("perFileResults" in pruned && pruned.perFileResults) {
+		return { ...pruned, perFileResults: capPerFileSnapshots(pruned.perFileResults) };
+	}
+	return pruned;
+}

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import { isBuiltin } from "node:module";
 import * as path from "node:path";
 import * as url from "node:url";
-import { isCompiledBinary } from "@oh-my-pi/pi-utils";
+import { isCompiledBinary, stripWindowsExtendedLengthPathPrefix } from "@oh-my-pi/pi-utils";
 import { BUNDLED_PI_REGISTRY_KEYS } from "./legacy-pi-bundled-keys";
 
 const IS_COMPILED_BINARY = isCompiledBinary();
@@ -425,7 +425,7 @@ function toImportSpecifier(resolvedPath: string): string {
 	if (isBundledVirtualSpecifier(resolvedPath)) {
 		return resolvedPath;
 	}
-	return url.pathToFileURL(resolvedPath).href;
+	return url.pathToFileURL(stripWindowsExtendedLengthPathPrefix(resolvedPath)).href;
 }
 
 function rewriteLegacyPiImports(source: string): string {