@oh-my-pi/pi-coding-agent 17.3.4 → 17.3.7

package/src/tools/render-utils.ts

@@ -599,79 +599,111 @@ export function truncateDiffByHunk(
 		let keptHunks = 0;
 
 		for (const seg of segments) {
+			if (kept.length >= maxLines) break;
 			if (seg.isChange) {
+				if (keptHunks >= maxHunks) break;
 				keptHunks++;
-				if (keptHunks > maxHunks) break;
 			}
-			kept.push(...seg.lines);
-			if (kept.length >= maxLines) break;
+			const take = Math.min(seg.lines.length, maxLines - kept.length);
+			for (let i = 0; i < take; i++) {
+				kept.push(seg.lines[i]!);
+			}
 		}
 
-		const keptStats = getDiffStats(kept.join("\n"));
 		return {
 			text: kept.join("\n"),
-			hiddenHunks: Math.max(0, totalStats.hunks - keptStats.hunks),
+			hiddenHunks: Math.max(0, totalStats.hunks - keptHunks),
 			hiddenLines: Math.max(0, lines.length - kept.length),
 		};
 	}
 
 	const contextBudget = maxLines - changeLineCount;
-	const contextSegments = segments.filter(s => !s.isChange && !s.isEllipsis);
+	const contextSegments = segments.filter(s => !s.isChange);
 	const totalContextLines = contextSegments.reduce((sum, s) => sum + s.lines.length, 0);
 
 	const kept: string[] = [];
 	let keptHunks = 0;
+	let keptSourceLines = 0;
 
 	if (totalContextLines <= contextBudget) {
 		for (const seg of segments) {
 			if (seg.isChange) {
+				if (keptHunks >= maxHunks) break;
 				keptHunks++;
-				if (keptHunks > maxHunks) break;
 			}
 			kept.push(...seg.lines);
+			keptSourceLines += seg.lines.length;
 		}
 	} else {
-		const contextRatio = contextSegments.length > 0 ? contextBudget / totalContextLines : 0;
+		const contextRatio = totalContextLines > 0 ? contextBudget / totalContextLines : 0;
+		let remainingContextBudget = contextBudget;
 
 		for (let i = 0; i < segments.length; i++) {
 			const seg = segments[i];
 
 			if (seg.isChange) {
+				if (keptHunks >= maxHunks) break;
 				keptHunks++;
-				if (keptHunks > maxHunks) break;
-				kept.push(...seg.lines);
-			} else if (seg.isEllipsis) {
 				kept.push(...seg.lines);
+				keptSourceLines += seg.lines.length;
+				continue;
+			}
+			if (remainingContextBudget <= 0) continue;
+
+			const allowedLines = Math.min(
+				remainingContextBudget,
+				Math.max(1, Math.floor(seg.lines.length * contextRatio)),
+			);
+			const outputStart = kept.length;
+			let sourceLinesAdded = 0;
+
+			if (seg.isEllipsis || seg.lines.length <= allowedLines) {
+				for (let j = 0; j < allowedLines; j++) {
+					kept.push(seg.lines[j]!);
+				}
+				sourceLinesAdded = allowedLines;
 			} else {
-				const allowedLines = Math.max(1, Math.floor(seg.lines.length * contextRatio));
 				const isBeforeChange = segments[i + 1]?.isChange;
 				const isAfterChange = segments[i - 1]?.isChange;
 
 				if (isBeforeChange && isAfterChange) {
-					const half = Math.ceil(allowedLines / 2);
-					if (seg.lines.length > allowedLines) {
-						kept.push(...seg.lines.slice(0, half));
+					if (allowedLines >= 3) {
+						const sourceBudget = allowedLines - 1;
+						const firstCount = Math.ceil(sourceBudget / 2);
+						const lastCount = sourceBudget - firstCount;
+						kept.push(...seg.lines.slice(0, firstCount));
 						kept.push("");
-						kept.push(...seg.lines.slice(-half));
+						if (lastCount > 0) kept.push(...seg.lines.slice(-lastCount));
+						sourceLinesAdded = sourceBudget;
 					} else {
-						kept.push(...seg.lines);
+						const firstCount = Math.ceil(allowedLines / 2);
+						const lastCount = allowedLines - firstCount;
+						kept.push(...seg.lines.slice(0, firstCount));
+						if (lastCount > 0) kept.push(...seg.lines.slice(-lastCount));
+						sourceLinesAdded = allowedLines;
 					}
 				} else if (isBeforeChange) {
 					kept.push(...seg.lines.slice(-allowedLines));
+					sourceLinesAdded = allowedLines;
 				} else if (isAfterChange) {
 					kept.push(...seg.lines.slice(0, allowedLines));
+					sourceLinesAdded = allowedLines;
 				} else {
-					kept.push(...seg.lines.slice(0, Math.min(allowedLines, 2)));
+					const take = Math.min(allowedLines, 2);
+					kept.push(...seg.lines.slice(0, take));
+					sourceLinesAdded = take;
 				}
 			}
+
+			keptSourceLines += sourceLinesAdded;
+			remainingContextBudget -= kept.length - outputStart;
 		}
 	}
 
-	const keptStats = getDiffStats(kept.join("\n"));
 	return {
 		text: kept.join("\n"),
-		hiddenHunks: Math.max(0, totalStats.hunks - keptStats.hunks),
-		hiddenLines: Math.max(0, lines.length - kept.length),
+		hiddenHunks: Math.max(0, totalStats.hunks - keptHunks),
+		hiddenLines: Math.max(0, lines.length - keptSourceLines),
 	};
 }
 

package/src/tools/think.ts

@@ -8,14 +8,26 @@ import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
 /** Whether a model transport can suppress native reasoning while private scratchpad thoughts are active. */
 export function supportsExternalThinking(model: Model | null | undefined): boolean {
 	if (!model) return false;
+	const compat = model.compat;
 	const requiresThinking =
 		model.api === "anthropic-messages" &&
-		model.compat !== undefined &&
-		"requiresThinkingEnabled" in model.compat &&
-		model.compat.requiresThinkingEnabled === true;
+		compat !== undefined &&
+		"requiresThinkingEnabled" in compat &&
+		compat.requiresThinkingEnabled === true;
 	if (model.reasoning && (requiresThinking || (model.thinking?.requiresEffort && !model.thinking.suppressWhenOff))) {
 		return false;
 	}
+	// Transports that reject `reasoning.effort` (xAI Grok 4 and the other
+	// reasoning-only Responses models) cannot honour `forceReasoningOff`, so the
+	// scratchpad would run alongside native reasoning instead of replacing it.
+	if (
+		model.reasoning &&
+		compat !== undefined &&
+		(("omitReasoningEffort" in compat && compat.omitReasoningEffort === true) ||
+			("supportsReasoningEffort" in compat && compat.supportsReasoningEffort === false))
+	) {
+		return false;
+	}
 	if (model.api === "google-generative-ai" || model.api === "google-gemini-cli" || model.api === "google-vertex") {
 		return !model.reasoning || model.thinking?.mode === "budget" || model.thinking?.suppressWhenOff === true;
 	}

package/src/tts/speech-enhancer.ts

@@ -15,7 +15,7 @@
  *   mechanical {@link SpeakableStream} cleanup — speech never blocks on the
  *   model.
  */
-import { type AssistantMessage, completeSimple } from "@oh-my-pi/pi-ai";
+import { type AssistantMessage, completeSimple, retryTransientCompletion } from "@oh-my-pi/pi-ai";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { getModelMatchPreferences, resolveModelRoleValue } from "../config/model-resolver";
@@ -82,20 +82,25 @@ export class SpeechEnhancer {
 			if (!apiKey) return null;
 			// Resolve metadata after getApiKey so the session-sticky credential is recorded first.
 			const metadata = this.#deps.metadataResolver?.(model.provider);
-			const timeout = AbortSignal.timeout(REWRITE_TIMEOUT_MS);
-			const response = await completeSimple(
-				model,
-				{
-					systemPrompt: [SYSTEM_PROMPT],
-					messages: [{ role: "user", content: boundBlock(block), timestamp: Date.now() }],
-				},
-				{
-					apiKey: registry.resolver(model, sessionId),
-					maxTokens: ANSWER_MAX_TOKENS,
-					disableReasoning: true,
-					metadata,
-					signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+			const response = await retryTransientCompletion(
+				() => {
+					const timeout = AbortSignal.timeout(REWRITE_TIMEOUT_MS);
+					return completeSimple(
+						model,
+						{
+							systemPrompt: [SYSTEM_PROMPT],
+							messages: [{ role: "user", content: boundBlock(block), timestamp: Date.now() }],
+						},
+						{
+							apiKey: registry.resolver(model, sessionId),
+							maxTokens: ANSWER_MAX_TOKENS,
+							disableReasoning: true,
+							metadata,
+							signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+						},
+					);
 				},
+				{ signal },
 			);
 			if (response.stopReason === "error") {
 				logger.debug("speech-enhancer: rewrite errored", { error: response.errorMessage });

package/src/utils/commit-message-generator.ts

@@ -4,7 +4,7 @@
  */
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
-import { completeSimple } from "@oh-my-pi/pi-ai";
+import { completeSimple, retryTransientCompletion } from "@oh-my-pi/pi-ai";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 
 import type { ModelRegistry } from "../config/model-registry";
@@ -106,17 +106,19 @@ export async function generateCommitMessage(
 
 		try {
 			const maxTokens = COMMIT_MAX_TOKENS;
-			const response = await completeSimple(
-				candidate.model,
-				{
-					systemPrompt: [COMMIT_SYSTEM_PROMPT],
-					messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
-				},
-				{
-					apiKey: registry.resolver(candidate.model, sessionId),
-					maxTokens,
-					reasoning: toReasoningEffort(candidate.thinkingLevel),
-				},
+			const response = await retryTransientCompletion(() =>
+				completeSimple(
+					candidate.model,
+					{
+						systemPrompt: [COMMIT_SYSTEM_PROMPT],
+						messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
+					},
+					{
+						apiKey: registry.resolver(candidate.model, sessionId),
+						maxTokens,
+						reasoning: toReasoningEffort(candidate.thinkingLevel),
+					},
+				),
 			);
 
 			if (response.stopReason === "error") {

package/src/utils/title-generator.ts

@@ -4,7 +4,7 @@
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import * as path from "node:path";
 
-import { type Api, type AssistantMessage, completeSimple, type Model } from "@oh-my-pi/pi-ai";
+import { type Api, type AssistantMessage, completeSimple, type Model, retryTransientCompletion } from "@oh-my-pi/pi-ai";
 import { StreamMarkupHealing } from "@oh-my-pi/pi-ai/utils/stream-markup-healing";
 import { isConPTYHosted } from "@oh-my-pi/pi-tui";
 import { isTerminalHeadless, logger, prompt } from "@oh-my-pi/pi-utils";
@@ -254,24 +254,28 @@ export async function generateTitleOnline(
 		const maxTokens = TITLE_MAX_TOKENS;
 		logger.debug("title-generator: request", { ...modelContext, maxTokens });
 
-		const response = await completeSimple(
-			model,
-			{
-				systemPrompt,
-				messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
-			},
-			{
-				apiKey: registry.resolver(model, sessionId),
-				maxTokens,
-				disableReasoning: true,
-				// Greedy decode: titling is extraction, not generation. Backends that
-				// default temperature high (e.g. Ollama's 0.8) otherwise garble names
-				// from the message ("hashline" → "HasHroshi"). Providers whose models
-				// reject sampling params drop this via `supportsSamplingParams`.
-				temperature: 0,
-				metadata,
-				signal,
-			},
+		const response = await retryTransientCompletion(
+			() =>
+				completeSimple(
+					model,
+					{
+						systemPrompt,
+						messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
+					},
+					{
+						apiKey: registry.resolver(model, sessionId),
+						maxTokens,
+						disableReasoning: true,
+						// Greedy decode: titling is extraction, not generation. Backends that
+						// default temperature high (e.g. Ollama's 0.8) otherwise garble names
+						// from the message ("hashline" → "HasHroshi"). Providers whose models
+						// reject sampling params drop this via `supportsSamplingParams`.
+						temperature: 0,
+						metadata,
+						signal,
+					},
+				),
+			{ signal },
 		);
 
 		if (response.stopReason === "error") {

package/src/vibe/runtime.ts

@@ -421,11 +421,17 @@ export class VibeSessionRegistry {
 	}
 
 	/**
-	 * Insert a bare worker record without the spawn/job machinery. Test-only —
-	 * lets {@link aggregateVibeWorkerTokensPerSecond} be exercised against a
-	 * fake roster + AgentRegistry session without driving a real turn.
+	 * Insert a bare worker record without the spawn machinery. Test-only —
+	 * lets focused runtime tests attach an optional synthetic in-flight job.
 	 */
-	registerRecordForTests(record: { id: string; cli?: VibeCli; ownerId: string; state?: VibeSessionState }): void {
+	registerRecordForTests(record: {
+		id: string;
+		cli?: VibeCli;
+		ownerId: string;
+		state?: VibeSessionState;
+		jobId?: string;
+	}): void {
+		const now = Date.now();
 		this.#records.set(record.id, {
 			id: record.id,
 			cli: record.cli ?? "fast",
@@ -434,8 +440,11 @@ export class VibeSessionRegistry {
 			parentSessionFile: null,
 			agent: getBundledAgent("sonic")!,
 			state: record.state ?? "running",
-			createdAt: Date.now(),
-			lastActivityAt: Date.now(),
+			createdAt: now,
+			lastActivityAt: now,
+			turn: record.jobId
+				? { jobId: record.jobId, message: "test turn", startedAt: now, trace: [], toolCount: 0 }
+				: undefined,
 			queue: [],
 			turnCount: 0,
 			killed: false,
@@ -1113,25 +1122,31 @@ export class VibeSessionRegistry {
 			if (job?.status === "running") runningJobs.push(job);
 		}
 
-		let waited = false;
+		let waitEndedByTimeout = false;
 		if (runningJobs.length > 0 && collectSettled().length === 0) {
-			waited = true;
 			const timeoutMs = Math.max(1, Math.trunc(args.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS));
 			const watchedJobIds = runningJobs.map(job => job.id);
 			manager.watchJobs(watchedJobIds);
-			const { promise: timeoutPromise, resolve: timeoutResolve } = Promise.withResolvers<void>();
-			const timeoutHandle = setTimeout(() => timeoutResolve(), timeoutMs);
-			const racePromises: Promise<unknown>[] = [...runningJobs.map(job => job.promise), timeoutPromise];
+			const { promise: timeoutPromise, resolve: timeoutResolve } = Promise.withResolvers<"timeout">();
+			const timeoutHandle = setTimeout(() => timeoutResolve("timeout"), timeoutMs);
+			const racePromises: Array<Promise<"settled" | "timeout" | "aborted">> = [
+				...runningJobs.map(job => job.promise.then(() => "settled" as const)),
+				timeoutPromise,
+			];
 			let abortCleanup: (() => void) | undefined;
 			if (args.signal) {
-				const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<void>();
-				const onAbort = () => abortResolve();
-				args.signal.addEventListener("abort", onAbort, { once: true });
-				abortCleanup = () => args.signal?.removeEventListener("abort", onAbort);
+				const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<"aborted">();
+				const onAbort = () => abortResolve("aborted");
+				if (args.signal.aborted) {
+					onAbort();
+				} else {
+					args.signal.addEventListener("abort", onAbort, { once: true });
+					abortCleanup = () => args.signal?.removeEventListener("abort", onAbort);
+				}
 				racePromises.push(abortPromise);
 			}
 			try {
-				await Promise.race(racePromises);
+				waitEndedByTimeout = (await Promise.race(racePromises)) === "timeout";
 			} finally {
 				manager.unwatchJobs(watchedJobIds);
 				clearTimeout(timeoutHandle);
@@ -1144,7 +1159,7 @@ export class VibeSessionRegistry {
 		// Current in-flight state, independent of the snapshot: a session whose
 		// watched turn settled may already be mid queued follow-up.
 		const stillRunning = watched.filter(record => record.turn !== undefined).map(record => record.id);
-		return { settled, stillRunning, timedOut: waited && settled.length === 0 };
+		return { settled, stillRunning, timedOut: waitEndedByTimeout && settled.length === 0 };
 	}
 
 	/** Detach one parent's process-local workers without tombstoning their persisted conversations. */