@oh-my-pi/pi-coding-agent 10.5.0 → 10.6.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [10.6.0] - 2026-02-04
+### Breaking Changes
+
+- Removed `output_mode` parameter from grep tool—results now always use content mode with formatted match output
+- Renamed grep context parameters from `context_pre`/`context_post` to `pre`/`post`
+- Removed `n` (show line numbers) parameter—line numbers are now always displayed in grep results
+
+### Added
+
+- Added Jina as a web search provider option alongside Exa, Perplexity, and Anthropic
+- Added support for Jina Reader API integration with automatic provider detection when JINA_API_KEY is configured
+
+### Changed
+
+- Reformatted grep output to display matches grouped by file with numbered match headers and aligned context lines
+- Updated grep output to use `>>` prefix for match lines and aligned spacing for context lines for improved readability
+- Changed multiline matching to automatically enable when pattern contains literal newlines (`
+`)
+- Split grep context parameter into separate `context_pre` and `context_post` options for independent control of lines before and after matches
+- Updated grep tool to use configurable default context settings from `grep.contextBefore` and `grep.contextAfter` configuration
+- Added configurable grep context defaults and reduced the default to 1 line before, 3 lines after
+- Enabled the browser tool by default
+
+### Removed
+
+- Removed `filesWithMatches` and `count` output modes from grep tool
+
 ## [10.5.0] - 2026-02-04
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "10.5.0",
+	"version": "10.6.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -80,12 +80,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "10.5.0",
-		"@oh-my-pi/pi-agent-core": "10.5.0",
-		"@oh-my-pi/pi-ai": "10.5.0",
-		"@oh-my-pi/pi-natives": "10.5.0",
-		"@oh-my-pi/pi-tui": "10.5.0",
-		"@oh-my-pi/pi-utils": "10.5.0",
+		"@oh-my-pi/omp-stats": "10.6.0",
+		"@oh-my-pi/pi-agent-core": "10.6.0",
+		"@oh-my-pi/pi-ai": "10.6.0",
+		"@oh-my-pi/pi-natives": "10.6.0",
+		"@oh-my-pi/pi-tui": "10.6.0",
+		"@oh-my-pi/pi-utils": "10.6.0",
 		"@openai/agents": "^0.4.5",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",

package/src/config/settings-schema.ts

@@ -329,6 +329,26 @@ export const SETTINGS_SCHEMA = {
 		default: true,
 		ui: { tab: "tools", label: "Enable Grep", description: "Enable the grep tool for content searching" },
 	},
+	"grep.contextBefore": {
+		type: "number",
+		default: 1,
+		ui: {
+			tab: "tools",
+			label: "Grep context before",
+			description: "Lines of context before each grep match",
+			submenu: true,
+		},
+	},
+	"grep.contextAfter": {
+		type: "number",
+		default: 3,
+		ui: {
+			tab: "tools",
+			label: "Grep context after",
+			description: "Lines of context after each grep match",
+			submenu: true,
+		},
+	},
 	"notebook.enabled": {
 		type: "boolean",
 		default: true,
@@ -360,7 +380,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"browser.enabled": {
 		type: "boolean",
-		default: false,
+		default: true,
 		ui: {
 			tab: "tools",
 			label: "Enable Browser",
@@ -485,7 +505,7 @@ export const SETTINGS_SCHEMA = {
 	// ─────────────────────────────────────────────────────────────────────────
 	"providers.webSearch": {
 		type: "enum",
-		values: ["auto", "exa", "perplexity", "anthropic"] as const,
+		values: ["auto", "exa", "jina", "perplexity", "anthropic"] as const,
 		default: "auto",
 		ui: { tab: "services", label: "Web search provider", description: "Provider for web search tool", submenu: true },
 	},

package/src/cursor.ts

@@ -167,7 +167,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 			pattern: args.pattern,
 			path: args.path || undefined,
 			glob: args.glob || undefined,
-			output_mode: args.outputMode || undefined,
+			mode: args.outputMode || undefined,
 			context: args.context ?? args.contextBefore ?? args.contextAfter ?? undefined,
 			ignore_case: args.caseInsensitive || undefined,
 			type: args.type || undefined,

package/src/prompts/tools/grep.md

@@ -6,17 +6,13 @@ Powerful search tool built on ripgrep.
 - Supports full regex syntax (e.g., `log.*Error`, `function\\s+\\w+`)
 - Filter files with `glob` (e.g., `*.js`, `**/*.tsx`) or `type` (e.g., `js`, `py`, `rust`)
 - Pattern syntax uses ripgrep—literal braces need escaping (`interface\\{\\}` to find `interface{}` in Go)
-- For cross-line patterns like `struct \\{[\\s\\S]*?field`, use `multiline: true`
+- For cross-line patterns like `struct \\{[\\s\\S]*?field`, set `multiline: true` if needed
+- If the pattern contains a literal `\n`, multiline defaults to true
 </instruction>
 
 <output>
-Results depend on `output_mode`:
-- `content`: Matching lines with file paths and line numbers
-- `files_with_matches`: File paths only (one per line)
-- `count`: Match counts per file
-
-In `content` mode, truncated at 100 matches default (configurable via `limit`).
-For `files_with_matches` and `count` modes, use `limit` truncate results.
+Results are always content mode: matching lines with file paths and line numbers.
+Truncated at 100 matches by default (configurable via `limit`).
 </output>
 
 <critical>

package/src/tools/grep.ts

@@ -1,7 +1,7 @@
 import * as nodePath from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
-import { type GrepMatch as WasmGrepMatch, grep as wasmGrep } from "@oh-my-pi/pi-natives";
+
+import { grep as wasmGrep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
@@ -10,7 +10,7 @@ import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
-import { renderFileList, renderStatusLine, renderTreeList } from "../tui";
+import { renderStatusLine, renderTreeList } from "../tui";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
@@ -24,16 +24,11 @@ const grepSchema = Type.Object({
 	path: Type.Optional(Type.String({ description: "File or directory to search (default: cwd)" })),
 	glob: Type.Optional(Type.String({ description: "Filter files by glob pattern (e.g., '*.js')" })),
 	type: Type.Optional(Type.String({ description: "Filter by file type (e.g., js, py, rust)" })),
-	output_mode: Type.Optional(
-		StringEnum(["filesWithMatches", "content", "count"], {
-			description: "Output format (default: files_with_matches)",
-		}),
-	),
 	i: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
-	n: Type.Optional(Type.Boolean({ description: "Show line numbers (default: true)" })),
-	context: Type.Optional(Type.Number({ description: "Lines of context (default: 5)" })),
-	multiline: Type.Optional(Type.Boolean({ description: "Enable multiline matching (default: false)" })),
-	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches (default: 100 in content mode)" })),
+	pre: Type.Optional(Type.Number({ description: "Lines of context before matches" })),
+	post: Type.Optional(Type.Number({ description: "Lines of context after matches" })),
+	multiline: Type.Optional(Type.Boolean({ description: "Enable multiline matching" })),
+	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches (default: 100)" })),
 	offset: Type.Optional(Type.Number({ description: "Skip first N entries before applying limit (default: 0)" })),
 });
 
@@ -50,7 +45,6 @@ export interface GrepToolDetails {
 	fileCount?: number;
 	files?: string[];
 	fileMatches?: Array<{ path: string; count: number }>;
-	mode?: "content" | "filesWithMatches" | "count";
 	truncated?: boolean;
 	error?: string;
 }
@@ -86,7 +80,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<GrepToolDetails>,
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<GrepToolDetails>> {
-		const { pattern, path: searchDir, glob, type, output_mode, i, n, context, multiline, limit, offset } = params;
+		const { pattern, path: searchDir, glob, type, i, pre, post, multiline, limit, offset } = params;
 
 		return untilAborted(signal, async () => {
 			const normalizedPattern = pattern.trim();
@@ -105,10 +99,13 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			}
 			const normalizedLimit = rawLimit !== undefined && rawLimit > 0 ? rawLimit : undefined;
 
-			const normalizedContext = context ?? 5;
-			const showLineNumbers = n ?? true;
+			const defaultContextBefore = this.session.settings.get("grep.contextBefore");
+			const defaultContextAfter = this.session.settings.get("grep.contextAfter");
+			const normalizedContextBefore = pre ?? defaultContextBefore;
+			const normalizedContextAfter = post ?? defaultContextAfter;
 			const ignoreCase = i ?? false;
-			const hasContentHints = limit !== undefined || context !== undefined;
+			const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
+			const effectiveMultiline = multiline ?? patternHasNewline;
 
 			const searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
 			const scopePath = (() => {
@@ -124,9 +121,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				throw new ToolError(`Path not found: ${searchPath}`);
 			}
 
-			const effectiveOutputMode = output_mode ?? (!isDirectory || hasContentHints ? "content" : "filesWithMatches");
-			const effectiveLimit =
-				effectiveOutputMode === "content" ? (normalizedLimit ?? DEFAULT_MATCH_LIMIT) : normalizedLimit;
+			const effectiveOutputMode = "content";
+			const effectiveLimit = normalizedLimit ?? DEFAULT_MATCH_LIMIT;
 
 			// Run WASM grep
 			let result: Awaited<ReturnType<typeof wasmGrep>>;
@@ -137,11 +133,12 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					glob: glob?.trim() || undefined,
 					type: type?.trim() || undefined,
 					ignoreCase,
-					multiline: multiline ?? false,
+					multiline: effectiveMultiline,
 					hidden: true,
 					maxCount: effectiveLimit,
 					offset: normalizedOffset > 0 ? normalizedOffset : undefined,
-					context: effectiveOutputMode === "content" ? normalizedContext : undefined,
+					contextBefore: normalizedContextBefore,
+					contextAfter: normalizedContextAfter,
 					maxColumns: DEFAULT_MAX_COLUMN,
 					mode: effectiveOutputMode,
 				});
@@ -180,71 +177,66 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					matchCount: 0,
 					fileCount: 0,
 					files: [],
-					mode: effectiveOutputMode,
 					truncated: false,
 				};
 				return toolResult(details).text("No matches found").done();
 			}
 
-			let outputLines: string[] = [];
+			const outputLines: string[] = [];
 			let linesTruncated = false;
+			let matchIndex = 0;
 
 			for (const match of result.matches) {
 				recordFile(match.path);
 				const relativePath = formatPath(match.path);
 
-				if (effectiveOutputMode === "content") {
-					// Add context before
-					if (match.contextBefore) {
-						for (const ctx of match.contextBefore) {
-							outputLines.push(
-								showLineNumbers
-									? `${relativePath}-${ctx.lineNumber}- ${ctx.line}`
-									: `${relativePath}- ${ctx.line}`,
-							);
-						}
+				matchIndex += 1;
+				if (matchIndex > 1) {
+					outputLines.push("");
+				}
+				outputLines.push(`${matchIndex}. ${relativePath}:${match.lineNumber}`);
+
+				const lineNumbers: number[] = [match.lineNumber];
+				if (match.contextBefore) {
+					for (const ctx of match.contextBefore) {
+						lineNumbers.push(ctx.lineNumber);
 					}
+				}
+				if (match.contextAfter) {
+					for (const ctx of match.contextAfter) {
+						lineNumbers.push(ctx.lineNumber);
+					}
+				}
+				const lineWidth = Math.max(...lineNumbers.map(value => value.toString().length));
 
-					// Add match line
-					outputLines.push(
-						showLineNumbers
-							? `${relativePath}:${match.lineNumber}: ${match.line}`
-							: `${relativePath}: ${match.line}`,
-					);
+				const formatLine = (lineNumber: number, line: string, isMatch: boolean): string => {
+					const padded = lineNumber.toString().padStart(lineWidth, " ");
+					return isMatch ? `>>${padded} ${line}` : `  ${padded} ${line}`;
+				};
 
-					if (match.truncated) {
-						linesTruncated = true;
+				// Add context before
+				if (match.contextBefore) {
+					for (const ctx of match.contextBefore) {
+						outputLines.push(formatLine(ctx.lineNumber, ctx.line, false));
 					}
+				}
 
-					// Add context after
-					if (match.contextAfter) {
-						for (const ctx of match.contextAfter) {
-							outputLines.push(
-								showLineNumbers
-									? `${relativePath}-${ctx.lineNumber}- ${ctx.line}`
-									: `${relativePath}- ${ctx.line}`,
-							);
-						}
-					}
+				// Add match line
+				outputLines.push(formatLine(match.lineNumber, match.line, true));
 
-					// Track per-file counts
-					fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
-				} else if (effectiveOutputMode === "filesWithMatches") {
-					// One line per file
-					const matchWithCount = match as WasmGrepMatch & { matchCount?: number };
-					fileMatchCounts.set(relativePath, matchWithCount.matchCount ?? 1);
-				} else {
-					// count mode
-					const matchWithCount = match as WasmGrepMatch & { matchCount?: number };
-					fileMatchCounts.set(relativePath, matchWithCount.matchCount ?? 0);
+				if (match.truncated) {
+					linesTruncated = true;
 				}
-			}
 
-			// Format output based on mode
-			if (effectiveOutputMode === "filesWithMatches") {
-				outputLines = fileList;
-			} else if (effectiveOutputMode === "count") {
-				outputLines = fileList.map(f => `${f}:${fileMatchCounts.get(f) ?? 0}`);
+				// Add context after
+				if (match.contextAfter) {
+					for (const ctx of match.contextAfter) {
+						outputLines.push(formatLine(ctx.lineNumber, ctx.line, false));
+					}
+				}
+
+				// Track per-file counts
+				fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 			}
 
 			const rawOutput = outputLines.join("\n");
@@ -261,7 +253,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					path,
 					count: fileMatchCounts.get(path) ?? 0,
 				})),
-				mode: effectiveOutputMode,
 				truncated,
 				matchLimitReached: result.limitReached ? effectiveLimit : undefined,
 			};
@@ -295,15 +286,13 @@ interface GrepRenderArgs {
 	glob?: string;
 	type?: string;
 	i?: boolean;
-	n?: boolean;
-	context?: number;
+	pre?: number;
+	post?: number;
 	multiline?: boolean;
-	output_mode?: string;
 	limit?: number;
 	offset?: number;
 }
 
-const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
 
 export const grepToolRenderer = {
@@ -313,10 +302,13 @@ export const grepToolRenderer = {
 		if (args.path) meta.push(`in ${args.path}`);
 		if (args.glob) meta.push(`glob:${args.glob}`);
 		if (args.type) meta.push(`type:${args.type}`);
-		if (args.output_mode && args.output_mode !== "filesWithMatches") meta.push(`mode:${args.output_mode}`);
 		if (args.i) meta.push("case:insensitive");
-		if (args.n === false) meta.push("no-line-numbers");
-		if (args.context !== undefined && args.context > 0) meta.push(`context:${args.context}`);
+		if (args.pre !== undefined && args.pre > 0) {
+			meta.push(`pre:${args.pre}`);
+		}
+		if (args.post !== undefined && args.post > 0) {
+			meta.push(`post:${args.post}`);
+		}
 		if (args.multiline) meta.push("multiline");
 		if (args.limit !== undefined && args.limit > 0) meta.push(`limit:${args.limit}`);
 		if (args.offset !== undefined && args.offset > 0) meta.push(`offset:${args.offset}`);
@@ -369,13 +361,11 @@ export const grepToolRenderer = {
 
 		const matchCount = details?.matchCount ?? 0;
 		const fileCount = details?.fileCount ?? 0;
-		const mode = details?.mode ?? "filesWithMatches";
 		const truncation = details?.meta?.truncation;
 		const limits = details?.meta?.limits;
 		const truncated = Boolean(
 			details?.truncated || truncation || limits?.matchLimit || limits?.resultLimit || limits?.columnTruncated,
 		);
-		const files = details?.files ?? [];
 
 		if (matchCount === 0) {
 			const header = renderStatusLine(
@@ -385,10 +375,7 @@ export const grepToolRenderer = {
 			return new Text([header, formatEmptyMessage("No matches found", uiTheme)].join("\n"), 0, 0);
 		}
 
-		const summaryParts =
-			mode === "filesWithMatches"
-				? [formatCount("file", fileCount)]
-				: [formatCount("match", matchCount), formatCount("file", fileCount)];
+		const summaryParts = [formatCount("match", matchCount), formatCount("file", fileCount)];
 		const meta = [...summaryParts];
 		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
@@ -398,34 +385,51 @@ export const grepToolRenderer = {
 			uiTheme,
 		);
 
-		if (mode === "content") {
-			const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
-			const contentLines = textContent.split("\n").filter(line => line.trim().length > 0);
-			const matchLines = renderTreeList(
-				{
-					items: contentLines,
-					expanded,
-					maxCollapsed: COLLAPSED_TEXT_LIMIT,
-					itemType: "match",
-					renderItem: line => uiTheme.fg("toolOutput", line),
-				},
-				uiTheme,
-			);
-			return new Text([header, ...matchLines].join("\n"), 0, 0);
+		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
+		const rawLines = textContent.split("\n");
+		const hasSeparators = rawLines.some(line => line.trim().length === 0);
+		const matchGroups: string[][] = [];
+		if (hasSeparators) {
+			let current: string[] = [];
+			for (const line of rawLines) {
+				if (line.trim().length === 0) {
+					if (current.length > 0) {
+						matchGroups.push(current);
+						current = [];
+					}
+					continue;
+				}
+				current.push(line);
+			}
+			if (current.length > 0) matchGroups.push(current);
+		} else {
+			for (const line of rawLines) {
+				if (line.trim().length === 0) continue;
+				matchGroups.push([line]);
+			}
 		}
 
-		const fileEntries: Array<{ path: string; count?: number }> = details?.fileMatches?.length
-			? details.fileMatches.map(entry => ({ path: entry.path, count: entry.count }))
-			: files.map(path => ({ path }));
-		const fileLines = renderFileList(
+		const getCollapsedMatchLimit = (groups: string[][], maxLines: number): number => {
+			if (groups.length === 0) return 0;
+			let usedLines = 0;
+			let count = 0;
+			for (const group of groups) {
+				if (count > 0 && usedLines + group.length > maxLines) break;
+				usedLines += group.length;
+				count += 1;
+				if (usedLines >= maxLines) break;
+			}
+			return count;
+		};
+
+		const maxCollapsed = expanded ? matchGroups.length : getCollapsedMatchLimit(matchGroups, COLLAPSED_TEXT_LIMIT);
+		const matchLines = renderTreeList(
 			{
-				files: fileEntries.map(entry => ({
-					path: entry.path,
-					isDirectory: entry.path.endsWith("/"),
-					meta: entry.count !== undefined ? `(${entry.count} match${entry.count !== 1 ? "es" : ""})` : undefined,
-				})),
+				items: matchGroups,
 				expanded,
-				maxCollapsed: COLLAPSED_LIST_LIMIT,
+				maxCollapsed,
+				itemType: "match",
+				renderItem: group => group.map(line => uiTheme.fg("toolOutput", line)),
 			},
 			uiTheme,
 		);
@@ -440,7 +444,7 @@ export const grepToolRenderer = {
 		const extraLines =
 			truncationReasons.length > 0 ? [uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)] : [];
 
-		return new Text([header, ...fileLines, ...extraLines].join("\n"), 0, 0);
+		return new Text([header, ...matchLines, ...extraLines].join("\n"), 0, 0);
 	},
 	mergeCallAndResult: true,
 };

package/src/web/search/index.ts

@@ -1,7 +1,7 @@
 /**
  * Unified Web Search Tool
  *
- * Single tool supporting Anthropic, Perplexity, and Exa providers with
+ * Single tool supporting Anthropic, Perplexity, Exa, and Jina providers with
  * provider-specific parameters exposed conditionally.
  *
  * When EXA_API_KEY is available, additional specialized tools are exposed:
@@ -27,6 +27,7 @@ import { formatAge } from "../../tools/render-utils";
 import { findAnthropicAuth } from "./auth";
 import { searchAnthropic } from "./providers/anthropic";
 import { searchExa } from "./providers/exa";
+import { findApiKey as findJinaKey, searchJina } from "./providers/jina";
 import { findApiKey as findPerplexityKey, searchPerplexity } from "./providers/perplexity";
 import { renderWebSearchCall, renderWebSearchResult, type WebSearchRenderDetails } from "./render";
 import type { WebSearchProvider, WebSearchResponse } from "./types";
@@ -36,7 +37,7 @@ import { WebSearchProviderError } from "./types";
 export const webSearchSchema = Type.Object({
 	query: Type.String({ description: "Search query" }),
 	provider: Type.Optional(
-		StringEnum(["auto", "exa", "anthropic", "perplexity"], {
+		StringEnum(["auto", "exa", "jina", "anthropic", "perplexity"], {
 			description: "Search provider (default: auto)",
 		}),
 	),
@@ -50,7 +51,7 @@ export const webSearchSchema = Type.Object({
 
 export type WebSearchParams = {
 	query: string;
-	provider?: "auto" | "exa" | "anthropic" | "perplexity";
+	provider?: "auto" | "exa" | "jina" | "anthropic" | "perplexity";
 	recency?: "day" | "week" | "month" | "year";
 	limit?: number;
 };
@@ -70,6 +71,9 @@ async function getAvailableProviders(): Promise<WebSearchProvider[]> {
 	const exaKey = await findExaKey();
 	if (exaKey) providers.push("exa");
 
+	const jinaKey = await findJinaKey();
+	if (jinaKey) providers.push("jina");
+
 	const perplexityKey = await findPerplexityKey();
 	if (perplexityKey) providers.push("perplexity");
 
@@ -83,6 +87,8 @@ function formatProviderLabel(provider: WebSearchProvider): string {
 	switch (provider) {
 		case "exa":
 			return "Exa";
+		case "jina":
+			return "Jina";
 		case "perplexity":
 			return "Perplexity";
 		case "anthropic":
@@ -237,6 +243,11 @@ async function executeWebSearch(
 					query: params.query,
 					num_results: params.limit,
 				});
+			} else if (provider === "jina") {
+				response = await searchJina({
+					query: params.query,
+					num_results: params.limit,
+				});
 			} else if (provider === "anthropic") {
 				response = await searchAnthropic({
 					query: params.query,
@@ -279,7 +290,7 @@ async function executeWebSearch(
 /**
  * Web search tool implementation.
  *
- * Supports Anthropic, Perplexity, and Exa providers with automatic fallback.
+ * Supports Anthropic, Perplexity, Exa, and Jina providers with automatic fallback.
  * Session is accepted for interface consistency but not used.
  */
 export class WebSearchTool implements AgentTool<typeof webSearchSchema, WebSearchRenderDetails> {

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

@@ -0,0 +1,76 @@
+/**
+ * Jina Reader Web Search Provider
+ *
+ * Uses the Jina Reader `s.jina.ai` endpoint to fetch search results with
+ * cleaned content.
+ */
+
+import { getEnvApiKey } from "@oh-my-pi/pi-ai";
+import type { WebSearchResponse, WebSearchSource } from "../../../web/search/types";
+import { WebSearchProviderError } from "../../../web/search/types";
+
+const JINA_SEARCH_URL = "https://s.jina.ai";
+
+export interface JinaSearchParams {
+	query: string;
+	num_results?: number;
+}
+
+interface JinaSearchResult {
+	title?: string | null;
+	url?: string | null;
+	content?: string | null;
+}
+
+type JinaSearchResponse = JinaSearchResult[];
+
+/** Find JINA_API_KEY from environment or .env files. */
+export function findApiKey(): string | null {
+	return getEnvApiKey("jina") ?? null;
+}
+
+/** Call Jina Reader search API. */
+async function callJinaSearch(apiKey: string, query: string): Promise<JinaSearchResponse> {
+	const requestUrl = `${JINA_SEARCH_URL}/${encodeURIComponent(query)}`;
+	const response = await fetch(requestUrl, {
+		headers: {
+			Accept: "application/json",
+			Authorization: `Bearer ${apiKey}`,
+		},
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new WebSearchProviderError("jina", `Jina API error (${response.status}): ${errorText}`, response.status);
+	}
+
+	const data = (await response.json()) as unknown;
+	return Array.isArray(data) ? (data as JinaSearchResponse) : [];
+}
+
+/** Execute Jina web search. */
+export async function searchJina(params: JinaSearchParams): Promise<WebSearchResponse> {
+	const apiKey = findApiKey();
+	if (!apiKey) {
+		throw new Error("JINA_API_KEY not found. Set it in environment or .env file.");
+	}
+
+	const response = await callJinaSearch(apiKey, params.query);
+	const sources: WebSearchSource[] = [];
+
+	for (const result of response) {
+		if (!result?.url) continue;
+		sources.push({
+			title: result.title ?? result.url,
+			url: result.url,
+			snippet: result.content ?? undefined,
+		});
+	}
+
+	const limitedSources = params.num_results ? sources.slice(0, params.num_results) : sources;
+
+	return {
+		provider: "jina",
+		sources: limitedSources,
+	};
+}

package/src/web/search/render.ts

@@ -113,7 +113,9 @@ export function renderWebSearchResult(
 				? "Perplexity"
 				: provider === "exa"
 					? "Exa"
-					: "Unknown";
+					: provider === "jina"
+						? "Jina"
+						: "Unknown";
 	const queryPreview = args?.query
 		? truncateToWidth(args.query, 80)
 		: searchQueries[0]

package/src/web/search/types.ts

@@ -1,11 +1,11 @@
 /**
  * Web Search Types
  *
- * Unified types for web search responses across Anthropic and Perplexity providers.
+ * Unified types for web search responses across supported providers.
  */
 
 /** Supported web search providers */
-export type WebSearchProvider = "exa" | "anthropic" | "perplexity" | "gemini" | "codex";
+export type WebSearchProvider = "exa" | "jina" | "anthropic" | "perplexity" | "gemini" | "codex";
 
 /** Source returned by search (all providers) */
 export interface WebSearchSource {