@oh-my-pi/pi-coding-agent 15.1.7 → 15.1.8

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [15.1.8] - 2026-05-20
+
+### Fixed
+
+- Fixed streaming edit previews for `apply_patch` and `hashline` jittering as the model typed `+added` lines. Two root causes addressed: (1) the trailing partial line of the streaming text input is now trimmed at each tick so a half-typed `+added` line no longer flickers; (2) the preview is rendered in the model's input order during streaming instead of re-deriving a unified diff via `Diff.structuredPatch`, whose coalescing previously reshuffled existing `+added` lines downward each time a new `-removed` line arrived. Existing additions now stay put and the preview only grows at the bottom while streaming. A residual trailing `-removed`/hunk-header block whose matching `+added` companion has not yet arrived is also suppressed until the additions land.
+- Fixed Perplexity web search appearing "logged out" roughly an hour after `omp auth login perplexity`. The search provider's `findOAuthToken` was honoring the bogus `expires = login_time + 1h` written by older logins (Perplexity JWTs typically omit `exp` because sessions are server-side) and silently dropping the credential. The loader now decodes the JWT's `exp` claim directly and only skips when the JWT itself is expired; tokens without an `exp` claim are treated as non-expiring.
+
 ## [15.1.7] - 2026-05-19
 
 ### Fixed

package/dist/types/edit/streaming.d.ts

@@ -26,6 +26,13 @@ export interface StreamingDiffContext {
     fuzzyThreshold?: number;
     allowFuzzy?: boolean;
     hashlineAutoDropPureInsertDuplicates?: boolean;
+    /**
+     * True while the tool's arguments are still streaming in. Strategies that
+     * accept free-form text input (apply_patch, hashline) trim the trailing
+     * partial line so per-character growth of an in-flight `+added` line does
+     * not flicker in the preview.
+     */
+    isStreaming?: boolean;
 }
 export interface EditStreamingStrategy<Args = unknown> {
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.1.7",
+	"version": "15.1.8",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,12 +47,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "15.1.7",
-		"@oh-my-pi/pi-agent-core": "15.1.7",
-		"@oh-my-pi/pi-ai": "15.1.7",
-		"@oh-my-pi/pi-natives": "15.1.7",
-		"@oh-my-pi/pi-tui": "15.1.7",
-		"@oh-my-pi/pi-utils": "15.1.7",
+		"@oh-my-pi/omp-stats": "15.1.8",
+		"@oh-my-pi/pi-agent-core": "15.1.8",
+		"@oh-my-pi/pi-ai": "15.1.8",
+		"@oh-my-pi/pi-natives": "15.1.8",
+		"@oh-my-pi/pi-tui": "15.1.8",
+		"@oh-my-pi/pi-utils": "15.1.8",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/edit/streaming.ts

@@ -45,6 +45,13 @@ export interface StreamingDiffContext {
 	fuzzyThreshold?: number;
 	allowFuzzy?: boolean;
 	hashlineAutoDropPureInsertDuplicates?: boolean;
+	/**
+	 * True while the tool's arguments are still streaming in. Strategies that
+	 * accept free-form text input (apply_patch, hashline) trim the trailing
+	 * partial line so per-character growth of an in-flight `+added` line does
+	 * not flicker in the preview.
+	 */
+	isStreaming?: boolean;
 }
 
 export interface EditStreamingStrategy<Args = unknown> {
@@ -274,21 +281,146 @@ interface HashlineArgs {
 	__partialJson?: string;
 }
 
+/**
+ * While streaming a free-form text payload (apply_patch envelope, hashline
+ * input), trim the trailing partial line so per-character growth of an
+ * in-flight `+added` line does not cause the diff preview to flicker. The
+ * full line will show on the next streaming tick once its `\n` arrives.
+ * Returns `text` unchanged when not streaming or when no newline is present.
+ */
+function trimTrailingPartialLine(text: string, isStreaming: boolean | undefined): string {
+	if (!isStreaming) return text;
+	const idx = text.lastIndexOf("\n");
+	if (idx === -1) return "";
+	return text.slice(0, idx + 1);
+}
+
+/**
+ * Build a per-file diff preview directly from a partial `apply_patch`
+ * envelope by emitting its body lines in *input order*. This bypasses the
+ * file-state re-diff (`computePatchDiff` → `Diff.structuredPatch`) whose
+ * coalescing reorders the model's `-old +new -old +new` stream into
+ * `-old -old +new +new` and visibly shifts existing `+added` lines
+ * downward each time a new `-` arrives. The preview therefore grows
+ * monotonically at the bottom while streaming and only becomes a real
+ * unified diff once the args are complete.
+ */
+function buildApplyPatchNaturalOrderPreviews(input: string): PerFileDiffPreview[] | null {
+	const lines = input.split("\n");
+	const groups = new Map<string, string[]>();
+	let currentPath: string | undefined;
+	const ensure = (path: string): string[] => {
+		let bucket = groups.get(path);
+		if (!bucket) {
+			bucket = [];
+			groups.set(path, bucket);
+		}
+		return bucket;
+	};
+	for (const raw of lines) {
+		const trimmedEnd = raw.trimEnd();
+		if (trimmedEnd === BEGIN_PATCH_MARKER || trimmedEnd === END_PATCH_MARKER || trimmedEnd === ABORT_MARKER) {
+			continue;
+		}
+		if (trimmedEnd.startsWith("*** Add File: ")) {
+			currentPath = trimmedEnd.slice("*** Add File: ".length);
+			ensure(currentPath);
+			continue;
+		}
+		if (trimmedEnd.startsWith("*** Delete File: ")) {
+			currentPath = trimmedEnd.slice("*** Delete File: ".length);
+			ensure(currentPath);
+			continue;
+		}
+		if (trimmedEnd.startsWith("*** Update File: ")) {
+			currentPath = trimmedEnd.slice("*** Update File: ".length);
+			ensure(currentPath);
+			continue;
+		}
+		if (trimmedEnd.startsWith("*** Move to:") || trimmedEnd.startsWith("*** End of File")) {
+			continue;
+		}
+		if (!currentPath) continue;
+		// Diff body: keep `-/+/space`-prefixed lines and `@@` hunk headers in
+		// input order. parseDiffLine accepts the no-line-number legacy form so
+		// the renderer styles them as additions/removals/context naturally.
+		if (raw.startsWith("+") || raw.startsWith("-") || raw.startsWith(" ") || raw.startsWith("@@")) {
+			ensure(currentPath).push(raw);
+		}
+	}
+	if (groups.size === 0) return null;
+	const previews: PerFileDiffPreview[] = [];
+	for (const [path, body] of groups) {
+		if (body.length === 0) continue;
+		previews.push({ path, diff: body.join("\n") });
+	}
+	return previews.length > 0 ? previews : null;
+}
+
+/**
+ * Hashline equivalent: emit each section's `~payload` lines as `+added`
+ * lines in the order the model typed them. We deliberately omit op headers
+ * and removal targets from the streaming preview because their content
+ * lives in the file and would require a costly re-apply per tick; the
+ * complete unified diff is shown once streaming finishes.
+ */
+function buildHashlineNaturalOrderPreviews(
+	input: string,
+	defaultPath: string | undefined,
+): PerFileDiffPreview[] | null {
+	const lines = input.split("\n");
+	const groups = new Map<string, string[]>();
+	let currentPath = defaultPath ?? "";
+	const ensure = (path: string): string[] => {
+		let bucket = groups.get(path);
+		if (!bucket) {
+			bucket = [];
+			groups.set(path, bucket);
+		}
+		return bucket;
+	};
+	for (const raw of lines) {
+		if (isHashlineEnvelopeMarkerLine(raw)) continue;
+		if (isHashlineHeaderLine(raw)) {
+			currentPath = raw.trimEnd().slice(1).trim();
+			if (currentPath) ensure(currentPath);
+			continue;
+		}
+		if (raw.startsWith("~")) {
+			ensure(currentPath).push(`+${raw.slice(1)}`);
+		}
+	}
+	if (groups.size === 0) return null;
+	const previews: PerFileDiffPreview[] = [];
+	for (const [path, body] of groups) {
+		if (body.length === 0) continue;
+		previews.push({ path, diff: body.join("\n") });
+	}
+	return previews.length > 0 ? previews : null;
+}
+
 const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	extractCompleteEdits(args) {
 		return args;
 	},
 	async computeDiffPreview(args, ctx) {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
+		const input = trimTrailingPartialLine(args.input, ctx.isStreaming);
+		if (input.length === 0) return null;
+		if (ctx.isStreaming) {
+			// Skip the costly per-tick re-apply and avoid `Diff.structuredPatch`
+			// reordering by showing the model's `~payload` lines in input order.
+			return buildHashlineNaturalOrderPreviews(input, args.path);
+		}
 		ctx.signal.throwIfAborted();
 
 		let sections: HashlineInputSection[];
 		try {
-			sections = splitHashlineInputs(args.input, { cwd: ctx.cwd, path: args.path });
+			sections = splitHashlineInputs(input, { cwd: ctx.cwd, path: args.path });
 		} catch {
 			// Single-section fallback keeps the original error rendering for the
 			// "haven't typed `@@ PATH` yet" case.
-			const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd, {
+			const result = await computeHashlineDiff({ input, path: args.path }, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
 			});
 			ctx.signal.throwIfAborted();
@@ -340,12 +472,21 @@ const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
 	},
 	async computeDiffPreview(args, ctx) {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
+		const input = trimTrailingPartialLine(args.input, ctx.isStreaming);
+		if (input.length === 0) return null;
+		if (ctx.isStreaming) {
+			// Render the envelope's diff body in input order so newly streamed
+			// `+added` lines append at the bottom instead of being shuffled
+			// upward as later `-removed` lines arrive and reorder the unified
+			// diff that `Diff.structuredPatch` would otherwise produce.
+			return buildApplyPatchNaturalOrderPreviews(input);
+		}
 		let entries: ApplyPatchEntry[];
 		try {
-			entries = expandApplyPatchToEntries({ input: args.input });
+			entries = expandApplyPatchToEntries({ input });
 		} catch {
 			try {
-				entries = expandApplyPatchToPreviewEntries({ input: args.input });
+				entries = expandApplyPatchToPreviewEntries({ input });
 			} catch (err) {
 				return [{ path: "", error: err instanceof Error ? err.message : String(err) }];
 			}

package/src/modes/components/tool-execution.ts

@@ -51,6 +51,49 @@ function cloneToolArgs<T>(args: T): T {
 	}
 }
 
+/**
+ * Drop trailing removal/hunk-header lines that appear in a streaming diff
+ * before the matching `+added` lines have arrived. Without this, a partial
+ * apply_patch / hashline preview shows `-old` first and then visibly grows
+ * the `+new` block beneath it — the "removals first, additions catching up"
+ * jitter. Once the next streaming tick brings the additions in, the trailing
+ * block reappears alongside them.
+ */
+function stripTrailingUnbalancedRemoval(diff: string | undefined): string | undefined {
+	if (!diff) return diff;
+	const lines = diff.split("\n");
+	let lastAddIdx = -1;
+	for (let i = lines.length - 1; i >= 0; i--) {
+		if (lines[i].startsWith("+")) {
+			lastAddIdx = i;
+			break;
+		}
+	}
+	let hasTrailingUnbalanced = false;
+	for (let i = lastAddIdx + 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.startsWith("-") || line.startsWith("@@")) {
+			hasTrailingUnbalanced = true;
+			break;
+		}
+	}
+	if (!hasTrailingUnbalanced) return diff;
+	if (lastAddIdx === -1) return "";
+	return lines.slice(0, lastAddIdx + 1).join("\n");
+}
+
+function stabilizeStreamingPreviews(previews: PerFileDiffPreview[]): PerFileDiffPreview[] {
+	let changed = false;
+	const next = previews.map(preview => {
+		if (!preview.diff) return preview;
+		const trimmed = stripTrailingUnbalancedRemoval(preview.diff);
+		if (trimmed === preview.diff) return preview;
+		changed = true;
+		return { ...preview, diff: trimmed ?? "" };
+	});
+	return changed ? next : previews;
+}
+
 function isEditLikeToolName(toolName: string): boolean {
 	return toolName === "edit" || toolName === "apply_patch";
 }
@@ -222,16 +265,18 @@ export class ToolExecutionComponent extends Container {
 		this.#editDiffAbort = controller;
 
 		try {
+			const isStreaming = !this.#argsComplete;
 			const previews = await strategy.computeDiffPreview(effectiveArgs, {
 				cwd: this.#cwd,
 				signal: controller.signal,
 				fuzzyThreshold: this.#editFuzzyThreshold,
 				allowFuzzy: this.#editAllowFuzzy,
 				hashlineAutoDropPureInsertDuplicates: this.#hashlineAutoDropPureInsertDuplicates,
+				isStreaming,
 			});
 			if (controller.signal.aborted) return;
 			if (previews) {
-				this.#editDiffPreview = previews;
+				this.#editDiffPreview = isStreaming ? stabilizeStreamingPreviews(previews) : previews;
 				this.#updateDisplay();
 				this.#ui.requestRender();
 			}

package/src/modes/interactive-mode.ts

@@ -584,11 +584,17 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (!this.loopModeEnabled || !this.loopPrompt) return;
 		const prompt = this.loopPrompt;
 		const loopAction = settings.get("loop.mode");
+		this.#deferLoopAutoSubmit(() => {
+			void this.#runLoopIteration(loopAction, prompt);
+		});
+	}
+
+	#deferLoopAutoSubmit(callback: () => void): void {
 		// Brief delay so the user has a chance to press Esc between iterations.
 		this.#loopAutoSubmitTimer = setTimeout(() => {
 			this.#loopAutoSubmitTimer = undefined;
 			if (!this.loopModeEnabled || !this.onInputCallback) return;
-			void this.#runLoopIteration(loopAction, prompt);
+			callback();
 		}, 800);
 	}
 
@@ -641,7 +647,32 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 	}
 
+	#isLoopAutoSubmitBlocked(): boolean {
+		return this.session.isStreaming || this.session.isCompacting;
+	}
+
+	#submitLoopPromptWhenReady(prompt: string): void {
+		if (!this.loopModeEnabled || this.loopPrompt !== prompt || !this.onInputCallback) return;
+		if (isLoopDurationExpired(this.loopLimit)) {
+			this.disableLoopMode("Loop time limit reached. Loop mode disabled.");
+			return;
+		}
+		if (this.#isLoopAutoSubmitBlocked()) {
+			this.#deferLoopAutoSubmit(() => this.#submitLoopPromptWhenReady(prompt));
+			return;
+		}
+		this.onInputCallback(this.startPendingSubmission({ text: prompt }));
+	}
+
 	async #runLoopIteration(action: "prompt" | "compact" | "reset", prompt: string): Promise<void> {
+		if (!this.loopModeEnabled || this.loopPrompt !== prompt || !this.onInputCallback) return;
+		if (this.#isLoopAutoSubmitBlocked()) {
+			this.#deferLoopAutoSubmit(() => {
+				void this.#runLoopIteration(action, prompt);
+			});
+			return;
+		}
+
 		if (!consumeLoopLimitIteration(this.loopLimit)) {
 			this.disableLoopMode("Loop limit reached. Loop mode disabled.");
 			return;
@@ -652,12 +683,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		} else if (action === "reset") {
 			await this.handleClearCommand();
 		}
-		if (!this.loopModeEnabled || !this.onInputCallback) return;
-		if (isLoopDurationExpired(this.loopLimit)) {
-			this.disableLoopMode("Loop time limit reached. Loop mode disabled.");
-			return;
-		}
-		this.onInputCallback(this.startPendingSubmission({ text: prompt }));
+		this.#submitLoopPromptWhenReady(prompt);
 	}
 
 	disableLoopMode(message = "Loop mode disabled."): void {

package/src/web/search/providers/perplexity.ts

@@ -174,6 +174,25 @@ export function findApiKey(): string | null {
 	return getEnvApiKey("perplexity") ?? null;
 }
 
+/**
+ * Decode a Perplexity JWT's `exp` claim, in ms. Returns `undefined` when the
+ * token has no `exp` (which is the common case — Perplexity sessions are
+ * server-side and effectively non-expiring from the client's POV).
+ */
+function jwtExpiryMs(token: string): number | undefined {
+	const parts = token.split(".");
+	if (parts.length !== 3) return undefined;
+	const payload = parts[1];
+	if (!payload) return undefined;
+	try {
+		const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8")) as { exp?: unknown };
+		if (typeof decoded.exp !== "number" || !Number.isFinite(decoded.exp)) return undefined;
+		return decoded.exp * 1000;
+	} catch {
+		return undefined;
+	}
+}
+
 async function findOAuthToken(): Promise<string | null> {
 	const now = Date.now();
 	try {
@@ -183,7 +202,11 @@ async function findOAuthToken(): Promise<string | null> {
 			if (record.credential.type !== "oauth") continue;
 			const credential = record.credential as PerplexityOAuthCredential;
 			if (!credential.access) continue;
-			if (credential.expires <= now + OAUTH_EXPIRY_BUFFER_MS) continue;
+			// Trust the JWT's own `exp` claim if it has one; otherwise treat as
+			// non-expiring. The stored `expires` field is unreliable: older logins
+			// wrote `loginTime + 1h` even though Perplexity JWTs typically lack `exp`.
+			const jwtExpiry = jwtExpiryMs(credential.access);
+			if (jwtExpiry !== undefined && jwtExpiry <= now + OAUTH_EXPIRY_BUFFER_MS) continue;
 			return credential.access;
 		}
 	} catch {