@oh-my-pi/pi-coding-agent 16.5.1 → 16.5.2

package/src/tools/grep.ts

@@ -48,7 +48,6 @@ import {
 	type LineRange,
 	parseLineRanges,
 	pathTargetsSsh,
-	probeLiteralPathExists,
 	type ResolvedSearchTarget,
 	resolveReadPath,
 	resolveToolSearchScope,
@@ -79,9 +78,6 @@ const searchSchema = type({
 	"path?": searchPathEntry.describe(
 		'file, directory, glob, internal URL, or "<file>:<lines>" selector to search; pass several as a semicolon-delimited list ("src; tests"). Omitted -> searches the workspace root (".")',
 	),
-	"selector?": type("string").describe(
-		'line selector applied to every searched file (e.g. "50-100", "50+10", "50-100,200-300"); never a path like "/"',
-	),
 	"case?": type("boolean").describe("case-sensitive search"),
 	"gitignore?": type("boolean").describe("respect gitignore"),
 	"skip?": type("number")
@@ -126,7 +122,6 @@ interface GrepPathSpec {
 	clean: string;
 	literalFilesystemMatch?: boolean;
 	ranges?: [LineRange, ...LineRange[]];
-	rangeSource?: "explicit" | "path";
 }
 
 /**
@@ -154,39 +149,9 @@ function isReadSelectorGrammar(sel: string): boolean {
 	return lower === "raw" || lower === "conflicts" || parseLineRanges(sel) !== null;
 }
 
-async function parsePathSpecs(
-	rawEntries: readonly string[],
-	cwd: string,
-	explicitSelector?: string,
-): Promise<GrepPathSpec[]> {
-	const normalizedSelector = explicitSelector?.trim() || undefined;
-	const explicitRanges = normalizedSelector === undefined ? undefined : parseLineRanges(normalizedSelector);
-	if (normalizedSelector !== undefined && !explicitRanges) {
-		throw new ToolError(
-			`selector "${normalizedSelector}" is invalid — use line ranges like "50-100", "50+10", or "50-100,200-300" without a leading colon`,
-		);
-	}
+async function parsePathSpecs(rawEntries: readonly string[], cwd: string): Promise<GrepPathSpec[]> {
 	const specs: GrepPathSpec[] = [];
 	for (const entry of rawEntries) {
-		if (explicitRanges) {
-			// Separate selector parameter makes `path` deterministic: first try the
-			// exact local filesystem path (with read-path normalization), then let
-			// archive/internal/URL resolution handle non-literal structured paths.
-			const rawPathHasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(entry);
-			const probe = rawPathHasScheme ? "missing" : await probeLiteralPathExists(entry, cwd);
-			// `"unknown"` covers EACCES/IO where we cannot confirm existence — treat
-			// it as a literal so a real file such as `test:1-2` under an unreadable
-			// parent is never silently reinterpreted as `test` + selector.
-			const literalMatch = probe !== "missing";
-			specs.push({
-				original: entry,
-				clean: literalMatch && !rawPathHasScheme ? resolveReadPath(entry, cwd) : entry,
-				literalFilesystemMatch: literalMatch,
-				ranges: explicitRanges,
-				rangeSource: "explicit",
-			});
-			continue;
-		}
 		// Internal URLs (`artifact://`, `skill://`, …) use the URL-aware splitter,
 		// which peels selector-shaped tails only for selector-capable schemes and
 		// leaves opaque ones (`mcp://`) intact. Unlike filesystem paths, their
@@ -212,7 +177,6 @@ async function parsePathSpecs(
 		const literalFilesystemMatch = strictSplit.sel !== undefined && split.sel === undefined;
 		let clean = literalFilesystemMatch ? resolveReadPath(entry, cwd) : entry;
 		let ranges: [LineRange, ...LineRange[]] | undefined;
-		let rangeSource: "path" | undefined;
 		if (!literalFilesystemMatch && split.sel) {
 			const parsed = parseLineRanges(split.sel);
 			if (!parsed) {
@@ -225,14 +189,12 @@ async function parsePathSpecs(
 			}
 			clean = split.path;
 			ranges = parsed;
-			rangeSource = "path";
 		}
 		specs.push({
 			original: entry,
 			clean,
 			literalFilesystemMatch,
 			ranges,
-			rangeSource: ranges ? rangeSource : undefined,
 		});
 	}
 	return specs;
@@ -950,7 +912,7 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 		_onUpdate?: AgentToolUpdateCallback<GrepToolDetails>,
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<GrepToolDetails>> {
-		const { pattern, path: rawPath, selector, case: caseSensitive, gitignore, skip } = params;
+		const { pattern, path: rawPath, case: caseSensitive, gitignore, skip } = params;
 
 		return untilAborted(signal, async () => {
 			// Preserve the pattern verbatim — leading/trailing whitespace is
@@ -968,7 +930,7 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 			const scopedPaths = toPathList(rawPath);
 			const effectivePaths = scopedPaths.length > 0 ? scopedPaths : ["."];
 			const rawEntries = await expandDelimitedPathEntries(effectivePaths, this.session.cwd);
-			const pathSpecs = await parsePathSpecs(rawEntries, this.session.cwd, selector);
+			const pathSpecs = await parsePathSpecs(rawEntries, this.session.cwd);
 			const materializedExternalPaths = new Map<string, string>();
 			const materializeExternalUrlForSearch = async (rawPath: string) => {
 				const target = parseReadUrlTarget(rawPath);
@@ -1002,7 +964,6 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 				const searchablePaths = internalResolution.paths;
 				const { virtualResources, virtualPathSet, virtualInputIndexes } = internalResolution;
 				const rangesByAbsPath = new Map<string, LineRange[]>();
-				const globalRanges = pathSpecs.find(spec => spec.rangeSource === "explicit")?.ranges;
 
 				if (
 					archiveUnreadable.length > 0 &&
@@ -1062,7 +1023,6 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 					for (let idx = 0; idx < pathSpecs.length; idx++) {
 						const spec = pathSpecs[idx];
 						if (!spec.ranges) continue;
-						if (spec.rangeSource === "explicit") continue;
 						if (virtualInputIndexes.has(idx)) continue;
 						const resolved = internalResolution.resolvedPathsByInput[idx];
 						if (!resolved) continue;
@@ -1268,11 +1228,11 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 					throw err;
 				}
 				result = mergeGrepResults(result, virtualResult, nativeMaxCount);
-				if (rangesByAbsPath.size > 0 || globalRanges) {
+				if (rangesByAbsPath.size > 0) {
 					const filteredMatches: GrepMatch[] = [];
 					for (const match of result.matches) {
 						const abs = matchAbsolutePath(match.path, searchPath);
-						const ranges = rangesByAbsPath.get(abs) ?? globalRanges;
+						const ranges = rangesByAbsPath.get(abs);
 						if (!ranges) {
 							// Path has no line-range constraint (e.g. a peer entry without `:N-M`).
 							filteredMatches.push(match);

package/src/tools/path-utils.ts

@@ -147,8 +147,14 @@ export function expandTilde(filePath: string, home?: string): string {
 }
 
 export function expandPath(filePath: string): string {
+	// Some models intermittently prefix an otherwise-valid path with a stray
+	// `:` (e.g. `:/abs/path`, `:../rel`). No real path starts with `:` and it
+	// never begins a selector against an absolute/relative path, so strip it
+	// before resolution — mirroring the `@`-prefix normalization above and the
+	// implicit stripping `write` already tolerates (issue #5508).
+	const deColoned = /^:(?=[/~]|\.\.?\/)/.test(filePath) ? filePath.slice(1) : filePath;
 	const normalized = stripWindowsExtendedLengthPathPrefix(
-		stripFileUrl(normalizeUnicodeSpaces(normalizeAtPrefix(filePath))),
+		stripFileUrl(normalizeUnicodeSpaces(normalizeAtPrefix(deColoned))),
 	);
 	return expandTilde(normalized);
 }

package/src/tools/read.ts

@@ -748,10 +748,7 @@ function splitPdfImageMemberReadPath(readPath: string): { pdfPath: string; membe
 
 const readSchema = type({
 	path: type("string").describe(
-		'Local path, internal URI (e.g. "omp://", "issue://123", "pr://123"), or URL. Inline :<sel> is still accepted for compatibility.',
-	),
-	"selector?": type("string").describe(
-		'selector without a leading colon (e.g. "50-100", "raw", "raw:50-100", "conflicts"); keeps `path` literal when filenames contain colons',
+		"Local path, internal URI (e.g. memory://, skill://), or URL. Inline selectors are supported.",
 	),
 });
 
@@ -2122,11 +2119,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<ReadToolDetails>> {
 		let { path: readPath } = params;
-		let explicitSelector = params.selector?.trim() || undefined;
-		let explicitParsedSelector = explicitSelector === undefined ? undefined : parseSel(explicitSelector);
-		if (explicitSelector !== undefined && explicitParsedSelector?.kind === "none") {
-			throw invalidSelector(explicitSelector);
-		}
 		if (readPath.startsWith("file://")) {
 			readPath = expandPath(readPath);
 		}
@@ -2147,13 +2139,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			if (!this.session.settings.get("fetch.enabled")) {
 				throw new ToolError("URL reads are disabled by settings.");
 			}
-			if (explicitParsedSelector?.kind === "conflicts") {
-				throw new ToolError("The explicit read selector `conflicts` is only supported for local files.");
-			}
-			const urlRaw =
-				explicitParsedSelector === undefined ? parsedUrlTarget.raw : isRawSelector(explicitParsedSelector);
-			const urlRanges =
-				explicitParsedSelector?.kind === "lines" ? explicitParsedSelector.ranges : parsedUrlTarget.ranges;
+			const urlRaw = parsedUrlTarget.raw;
+			const urlRanges = parsedUrlTarget.ranges;
 			if (urlRanges !== undefined && urlRanges.length > 1) {
 				const cached = await loadReadUrlCacheEntry(
 					this.session,
@@ -2169,14 +2156,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					immutable: true,
 				});
 			}
-			const urlRange = urlRanges?.[0];
-			const urlOffset = explicitParsedSelector?.kind === "lines" ? urlRange?.startLine : parsedUrlTarget.offset;
-			const urlLimit =
-				explicitParsedSelector?.kind === "lines" && urlRange
-					? urlRange.endLine !== undefined
-						? urlRange.endLine - urlRange.startLine + 1
-						: undefined
-					: parsedUrlTarget.limit;
+			const urlOffset = parsedUrlTarget.offset;
+			const urlLimit = parsedUrlTarget.limit;
 			if (urlOffset !== undefined || urlLimit !== undefined) {
 				const cached = await loadReadUrlCacheEntry(
 					this.session,
@@ -2202,10 +2183,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		// Use the internal-URL-aware splitter so malformed selectors are peeled
 		// off the URL and surfaced via parseSel rather than confusing handlers.
 		const internalRouter = InternalUrlRouter.instance();
+		let promotedSelector: string | undefined;
 		if (internalRouter.canHandle(readPath)) {
-			const internalTarget =
-				explicitSelector === undefined ? splitInternalUrlSel(readPath) : { path: readPath, sel: explicitSelector };
-			const parsed = explicitParsedSelector ?? parseSel(internalTarget.sel);
+			const internalTarget = splitInternalUrlSel(readPath);
+			const parsed = parseSel(internalTarget.sel);
 			if (internalTarget.sel !== undefined && parsed.kind === "none") {
 				throw new ToolError(
 					`Invalid selector ':${internalTarget.sel}' on '${internalTarget.path}'. Use :N, :N-M, :N+K, :N- (open-ended), a comma-separated list of ranges, :raw, or a range combined with raw (e.g. :raw:50-100).`,
@@ -2223,15 +2204,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				});
 				if (localFile) {
 					readPath = localFile.path;
-					// Promote the URL-embedded selector into the explicit-selector state so
-					// downstream literal-preferring routing does NOT re-split the synthesized
-					// `${localFile.path}:${sel}` string — a sibling literal file at that name
-					// would otherwise shadow the intended local:// URL selector semantics
-					// (issue #4618 reviewer feedback on c493d12).
-					if (explicitSelector === undefined && internalTarget.sel !== undefined) {
-						explicitSelector = internalTarget.sel;
-						explicitParsedSelector = parsed;
-					}
+					// Preserve a local:// selector separately so a sibling literal file
+					// cannot shadow the URL's selector semantics during filesystem routing.
+					promotedSelector = internalTarget.sel;
 				} else {
 					return this.#handleInternalUrl(internalTarget.path, parsed, signal);
 				}
@@ -2246,16 +2221,14 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		// Prefer a literal filesystem match over selector interpretation so real
 		// POSIX filenames containing selector-looking suffixes win over structured
-		// archive / sqlite / pdf-image dispatch. With explicit `selector`, `path`
-		// is exact: `path: "test:1-2", selector: "1-2"` means "lines 1-2 from
-		// the literal file test:1-2", without recursively depending on whether a
-		// longer `test:1-2:1-2` filename also exists (issue #4618).
+		// archive / sqlite / pdf-image dispatch. A selector promoted from local://
+		// remains separate so it cannot be mistaken for part of the resolved path.
 		const literalSplit =
-			explicitSelector === undefined
+			promotedSelector === undefined
 				? await splitPathAndSelPreferringLiteral(readPath, this.session.cwd)
-				: { path: readPath, sel: explicitSelector };
+				: { path: readPath, sel: promotedSelector };
 		const rawPathIsLiteral =
-			explicitSelector !== undefined
+			promotedSelector !== undefined
 				? readPath.includes(":") && (await probeLiteralPathExists(readPath, this.session.cwd)) !== "missing"
 				: literalSplit.sel === undefined && splitPathAndSel(readPath).sel !== undefined;
 
@@ -2263,9 +2236,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const archivePath = await this.#resolveArchiveReadPath(readPath, suffixCache, signal);
 			if (archivePath) {
 				const archiveSubPath =
-					explicitSelector === undefined
+					promotedSelector === undefined
 						? splitPathAndSel(archivePath.archiveSubPath)
-						: { path: archivePath.archiveSubPath, sel: explicitSelector };
+						: { path: archivePath.archiveSubPath, sel: promotedSelector };
 				const archiveParsed = parseSel(archiveSubPath.sel);
 				return this.#readArchive(
 					readPath,
@@ -3319,8 +3292,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 interface ReadRenderArgs {
 	path?: unknown;
 	file_path?: unknown;
-	selector?: unknown;
-	sel?: string;
 	// Legacy fields from old schema — tolerated for in-flight tool calls during transition
 	offset?: number;
 	limit?: number;
@@ -3384,20 +3355,10 @@ function formatReadPathLink(
 
 export const readToolRenderer = {
 	renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const baseRawPath =
-			typeof args.file_path === "string" ? args.file_path : typeof args.path === "string" ? args.path : "";
-		const explicitSelector =
-			typeof args.selector === "string"
-				? args.selector.trim().replace(/^:+/, "")
-				: args.sel?.trim().replace(/^:+/, "");
 		const rawPath =
-			explicitSelector && explicitSelector.length > 0 ? `${baseRawPath}:${explicitSelector}` : baseRawPath;
-		if (isReadableUrlPath(baseRawPath)) {
-			return renderReadUrlCall(
-				{ path: rawPath, raw: args.raw || explicitSelector?.toLowerCase() === "raw" },
-				_options,
-				uiTheme,
-			);
+			typeof args.file_path === "string" ? args.file_path : typeof args.path === "string" ? args.path : "";
+		if (isReadableUrlPath(rawPath)) {
+			return renderReadUrlCall({ path: rawPath, raw: args.raw }, _options, uiTheme);
 		}
 
 		const offset = args.offset;
@@ -3438,14 +3399,8 @@ export const readToolRenderer = {
 		if (result.isError) {
 			const rawErrorText = result.content?.find(c => c.type === "text")?.text ?? "";
 			const errorText = (rawErrorText || "Unknown error").replace(/^Error:\s*/, "");
-			const baseRawPath =
-				typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
-			const explicitSelector =
-				typeof args?.selector === "string"
-					? args.selector.trim().replace(/^:+/, "")
-					: args?.sel?.trim().replace(/^:+/, "");
 			const rawPath =
-				explicitSelector && explicitSelector.length > 0 ? `${baseRawPath}:${explicitSelector}` : baseRawPath;
+				typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
 			const filePath =
 				formatReadPathLink(rawPath, { offset: args?.offset, sourcePath: readSourceFsPath(result.details) }) ||
 				shortenPath(rawPath);
@@ -3472,14 +3427,8 @@ export const readToolRenderer = {
 		// echo next to the styled warning line below.
 		const contentText = details?.displayContent?.text ?? stripOutputNotice(rawText, details?.meta);
 		const imageContent = result.content?.find(c => c.type === "image");
-		const baseRawPath =
-			typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
-		const explicitSelector =
-			typeof args?.selector === "string"
-				? args.selector.trim().replace(/^:+/, "")
-				: args?.sel?.trim().replace(/^:+/, "");
 		const rawPath =
-			explicitSelector && explicitSelector.length > 0 ? `${baseRawPath}:${explicitSelector}` : baseRawPath;
+			typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
 		const renderPath = splitReadRenderPath(rawPath);
 		const lang = getLanguageFromPath(renderPath.path);
 

package/src/utils/title-generator.ts

@@ -40,6 +40,8 @@ const THINKING_TAG_ENVELOPE_RE = /<(think|thinking|reasoning)>\s*[\s\S]*?<\/\1>/
 const THINKING_FENCE_ENVELOPE_RE = /```(?:thinking|reasoning)\b[\s\S]*?```/gi;
 const LEADING_THINKING_TAG_RE = /^\s*<(think|thinking|reasoning)>\s*[\s\S]*?<\/\1>\s*/i;
 const LEADING_THINKING_FENCE_RE = /^\s*```(?:thinking|reasoning)\b[\s\S]*?```\s*/i;
+const LEADING_PROSE_THINKING_PREAMBLE_RE =
+	/^[ \t]*(?:(?:here(?:['’]s| is)[ \t]+(?:a|the|my)[ \t]+)|my[ \t]+)?(?:thinking|thought|reasoning)[ \t]+process[ \t]*:?[ \t]*(?:\r?\n|$)/i;
 
 function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel?: Model<Api>): Model<Api> | undefined {
 	const availableModels = registry.getAvailable();
@@ -250,13 +252,15 @@ function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): stri
 	}
 	// Stay lenient: prefer the first closed title marker in visible text, then
 	// fall back to a plain sentence after stripping only known leading leaked
-	// thinking envelopes plus any stray/unclosed title tag fragment.
+	// thinking envelopes plus any stray/unclosed title tag fragment. Reject a
+	// prose thinking preamble only on the markerless path: a later marked title
+	// remains authoritative.
 	const markedTitle = extractVisibleMarkedTitle(textTitle);
-	const cleanedTextTitle =
-		markedTitle ??
-		stripLeadingLeakedThinkingMarkup(textTitle)
-			.replace(/<\/?title>/gi, "")
-			.trim();
+	if (markedTitle !== undefined) return unwrapJsonTitle(markedTitle);
+	const cleanedTextTitle = stripLeadingLeakedThinkingMarkup(textTitle)
+		.replace(/<\/?title>/gi, "")
+		.trim();
+	if (LEADING_PROSE_THINKING_PREAMBLE_RE.test(cleanedTextTitle)) return "";
 	return unwrapJsonTitle(cleanedTextTitle);
 }
 

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

@@ -44,17 +44,26 @@ export async function getApiConfigs(
 	const useResponses = $env.PI_PERPLEXITY_RESPONSES === "1";
 	const configs: ApiConfig[] = [];
 
-	const perplexityKey = await authStorage.getApiKey("perplexity", sessionId, options);
-	if (perplexityKey) {
-		configs.push({
-			type: "api_key",
-			apiKey: perplexityKey,
-			provider: "perplexity",
-			chatBaseUrl: PERPLEXITY_CHAT_BASE_URL,
-			responsesBaseUrl: PERPLEXITY_RESPONSES_BASE_URL,
-			modelPrefix: "",
-			useResponses,
-		});
+	// A Perplexity OAuth session and a real API key are mutually exclusive here:
+	// when the active credential origin is OAuth, `getApiKey("perplexity")`
+	// returns the OAuth session JWT (OAuth wins in AuthStorage.getApiKey), not an
+	// api.perplexity.ai key. Emitting it as a direct api-key config makes the
+	// search loop send the session token as a Bearer to the direct API endpoint,
+	// which rejects it with 401 and masks the real (transport) failure — see #5315.
+	// Skip the direct config in that case; the OAuth ask-endpoint method covers it.
+	if (authStorage.getCredentialOrigin("perplexity")?.kind !== "oauth") {
+		const perplexityKey = await authStorage.getApiKey("perplexity", sessionId, options);
+		if (perplexityKey) {
+			configs.push({
+				type: "api_key",
+				apiKey: perplexityKey,
+				provider: "perplexity",
+				chatBaseUrl: PERPLEXITY_CHAT_BASE_URL,
+				responsesBaseUrl: PERPLEXITY_RESPONSES_BASE_URL,
+				modelPrefix: "",
+				useResponses,
+			});
+		}
 	}
 
 	const openrouterKey = await authStorage.getApiKey("openrouter", sessionId, options);

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

@@ -604,7 +604,7 @@ async function callPerplexityAsk(
 		requestParams.send_back_text_in_streaming_api = true;
 	}
 
-	const response = await (params.fetch ?? fetch)(PERPLEXITY_OAUTH_ASK_URL, {
+	const requestInit = {
 		method: "POST",
 		headers,
 		body: JSON.stringify({
@@ -612,7 +612,19 @@ async function callPerplexityAsk(
 			params: requestParams,
 		}),
 		signal: withHardTimeout(params.signal),
-	});
+	};
+
+	// The consumer ask endpoint intermittently drops the socket before sending an
+	// HTTP response (#5315). Retry the transport exactly once; once we hold an
+	// HTTP response (handled below) the outcome — including non-2xx — is final and
+	// never retried, so a real 401/429 is never papered over by a second attempt.
+	let response: Response;
+	try {
+		response = await (params.fetch ?? fetch)(PERPLEXITY_OAUTH_ASK_URL, requestInit);
+	} catch (error) {
+		if (params.signal?.aborted) throw error;
+		response = await (params.fetch ?? fetch)(PERPLEXITY_OAUTH_ASK_URL, requestInit);
+	}
 
 	if (!response.ok) {
 		const errorText = await response.text();