@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/tools/render-utils.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Shared utilities and constants for tool renderers.
+ *
+ * Provides consistent formatting, truncation, and display patterns across all
+ * tool renderers to ensure a unified TUI experience.
+ */
+import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
+import type { Ellipsis } from "@oh-my-pi/pi-natives";
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { Theme } from "../modes/theme/theme";
+import { type ResizedImage } from "../utils/image-resize";
+export { Ellipsis } from "@oh-my-pi/pi-natives";
+export { replaceTabs, truncateToWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
+/** Resolve inline image dimension caps from settings and viewport. */
+export declare function resolveImageOptions(): {
+    maxWidthCells: number;
+    maxHeightCells?: number;
+};
+/** Preview limits for collapsed/expanded views */
+export declare const PREVIEW_LIMITS: {
+    /** Lines shown in collapsed view */
+    readonly COLLAPSED_LINES: 3;
+    /** Lines shown in expanded view */
+    readonly EXPANDED_LINES: 12;
+    /** Items (files, results) shown in collapsed view */
+    readonly COLLAPSED_ITEMS: 8;
+    /** Output preview lines in collapsed view */
+    readonly OUTPUT_COLLAPSED: 3;
+    /** Output preview lines in expanded view */
+    readonly OUTPUT_EXPANDED: 10;
+    /** Max hunks shown when collapsed (edit tool) */
+    readonly DIFF_COLLAPSED_HUNKS: 8;
+    /** Max diff lines shown when collapsed (edit tool) */
+    readonly DIFF_COLLAPSED_LINES: 40;
+};
+/** Truncation lengths for different content types */
+export declare const TRUNCATE_LENGTHS: {
+    /** Short titles, labels */
+    readonly TITLE: 60;
+    /** Medium-length content (messages, previews) */
+    readonly CONTENT: 80;
+    /** Longer content (code, explanations) */
+    readonly LONG: 100;
+    /** Full line content */
+    readonly LINE: 110;
+    /** Very short (task previews, badges) */
+    readonly SHORT: 40;
+};
+/** Standard expand hint text */
+export declare const EXPAND_HINT = "(Ctrl+O for more)";
+/**
+ * Get first N lines of text as preview, with each line truncated.
+ */
+export declare function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[];
+/**
+ * Extract domain from URL, stripping www. prefix.
+ */
+export declare function getDomain(url: string): string;
+export { formatAge, formatBytes, formatCount, formatDuration, pluralize } from "@oh-my-pi/pi-utils";
+/**
+ * Get the appropriate status icon with color for a given state.
+ * Standardizes status icon usage across all renderers.
+ */
+export declare function formatStatusIcon(status: ToolUIStatus, theme: Theme, spinnerFrame?: number): string;
+/**
+ * Format the expand hint with proper theming.
+ * Returns empty string if already expanded or there is nothing more to show.
+ */
+export declare function formatExpandHint(theme: Theme, expanded?: boolean, hasMore?: boolean): string;
+/**
+ * Format a badge like [done] or [failed] with brackets and color.
+ */
+export declare function formatBadge(label: string, color: ToolUIColor, theme: Theme): string;
+/**
+ * Build a "more items" suffix line for truncated lists.
+ * Uses consistent wording pattern.
+ */
+export declare function formatMoreItems(remaining: number, itemType: string): string;
+export declare function formatMeta(meta: string[], theme: Theme): string;
+export declare function formatErrorMessage(message: string | undefined, theme: Theme): string;
+export declare function formatEmptyMessage(message: string, theme: Theme): string;
+export type CodeFrameMarker = "" | " " | "*" | "+" | "-" | ">";
+export declare function formatCodeFrameLine(marker: CodeFrameMarker, lineNumber: string | number, content: string, lineNumberWidth: number): string;
+export type ToolUIStatus = "success" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
+export type ToolUIColor = "success" | "error" | "warning" | "accent" | "muted";
+export interface ToolUITitleOptions {
+    bold?: boolean;
+}
+export declare function formatTitle(label: string, theme: Theme, options?: ToolUITitleOptions): string;
+export declare function formatDiagnostics(diag: {
+    errored: boolean;
+    summary: string;
+    messages: string[];
+}, expanded: boolean, theme: Theme, getLangIcon: (filePath: string) => string): string;
+export interface DiffStats {
+    added: number;
+    removed: number;
+    hunks: number;
+    lines: number;
+}
+export declare function getDiffStats(diffText: string): DiffStats;
+export declare function formatDiffStats(added: number, removed: number, hunks: number, theme: Theme): string;
+export declare function truncateDiffByHunk(diffText: string, maxHunks: number, maxLines: number): {
+    text: string;
+    hiddenHunks: number;
+    hiddenLines: number;
+};
+export declare function shortenPath(filePath: string, homeDir?: string): string;
+export declare function formatToolWorkingDirectory(workdir: string | undefined, projectDir: string): string | undefined;
+export declare function formatScreenshot(opts: {
+    saveFullRes: boolean;
+    savedMimeType: string;
+    savedByteLength: number;
+    dest: string;
+    resized: ResizedImage;
+}): string[];
+export declare function wrapBrackets(text: string, theme: Theme): string;
+export declare const PARSE_ERRORS_LIMIT = 20;
+export declare function dedupeParseErrors(errors: string[] | undefined): string[];
+export declare function formatParseErrors(errors: string[]): string[];
+/**
+ * Group `rawLines` by blank-line separators, mirroring the historical search /
+ * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
+ * runs of blank lines; otherwise collapses non-empty lines into a single group.
+ */
+export declare function splitGroupsByBlankLine(rawLines: string[]): string[][];
+/**
+ * Standard width+expand keyed render cache used by every search-style tool
+ * renderer. `compute` re-runs only when the cache key changes; the returned
+ * Component is the canonical `{ render, invalidate }` pair.
+ */
+export declare function createCachedComponent(getExpanded: () => boolean, compute: (width: number, expanded: boolean) => string[]): Component;
+/**
+ * Append the indented bullet list of parse errors (capped at
+ * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the
+ * total exceeds the cap. No-op when `parseErrors` is empty.
+ */
+export declare function appendParseErrorsBulletList(lines: string[], parseErrors: readonly string[] | undefined, theme: Theme): void;
+/**
+ * Human-readable summary string for the parse-issues count, capped by
+ * {@link PARSE_ERRORS_LIMIT}.
+ */
+export declare function formatParseErrorsCountLabel(parseErrors: readonly string[]): string;
+export interface LspBatchRequest {
+    id: string;
+    flush: boolean;
+}
+export declare function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined;

package/dist/types/tools/renderers.d.ts

@@ -0,0 +1,26 @@
+/**
+ * TUI renderers for built-in tools.
+ *
+ * These provide rich visualization for tool calls and results in the TUI.
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+type ToolRenderer = {
+    renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
+    renderResult: (result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: unknown;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: Record<string, unknown>;
+    }, theme: Theme, args?: unknown) => Component;
+    mergeCallAndResult?: boolean;
+    /** Render without background box, inline in the response flow */
+    inline?: boolean;
+};
+export declare const toolRenderers: Record<string, ToolRenderer>;
+export {};

package/dist/types/tools/report-tool-issue.d.ts

@@ -0,0 +1,123 @@
+/**
+ * report_tool_issue — automated QA tool for tracking unexpected tool behavior.
+ *
+ * Enabled by default; gated behind PI_AUTO_QA=1 / `dev.autoqa` so a user
+ * who flips the setting off short-circuits injection entirely.
+ * Always injected into every agent (including subagents) regardless of tool selection.
+ * Records grievances to a local SQLite database; never throws.
+ *
+ * Before the first record lands, the user's consent is checked. If they've
+ * never been asked (`dev.autoqa.consent === "unset"`) the process-global
+ * consent handler — wired by `InteractiveMode` to a Yes/No popup — is
+ * invoked exactly once and the decision is persisted. Subsequent calls
+ * (including from subagents) read the cached decision without prompting.
+ *
+ * When the user grants consent, push is automatically active against the
+ * bundled endpoint (`dev.autoqaPush.endpoint`, default `qa.omp.sh`). Each
+ * insert schedules a background flush that POSTs pending rows and deletes
+ * them on HTTP 2xx. `PI_AUTO_QA_PUSH=1` forces push in non-interactive
+ * environments where the consent dialog never fires. Tool execution is
+ * never blocked on the network and never throws.
+ */
+import { Database } from "bun:sqlite";
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Settings } from "..";
+import type { ToolSession } from "./index";
+export declare function isAutoQaEnabled(settings?: Settings): boolean;
+/**
+ * Resolver for the user's "share grievances?" consent.
+ *
+ * Return values:
+ *   - `true`  — user agreed; record + ship for this run and persist.
+ *   - `false` — user declined; suppress for this run and persist.
+ *   - `null`  — user dismissed the dialog (ESC, click-away, …) without
+ *               picking an option. The decision is NOT cached or persisted,
+ *               so the next `report_tool_issue` invocation re-prompts.
+ *
+ * Persistence is the tool's job (so subagent invocations can persist into
+ * the disk-backed `Settings` instance the host registered alongside the
+ * handler), not the handler's. Implementations live in hosts that have UI
+ * affordances — today only `InteractiveMode`. When no handler is
+ * registered (CLI subcommands, tests, non-interactive runs) consent
+ * defaults to `false` — the explicit "don't collect by default" stance.
+ */
+export type AutoQaConsentHandler = () => Promise<boolean | null>;
+/**
+ * Register the consent handler and the persistent {@link Settings} instance
+ * the decision should be written to. Passing `null` clears the handler
+ * (e.g. on `InteractiveMode` teardown). Re-registration is authoritative.
+ */
+export declare function setAutoQaConsentHandler(handler: AutoQaConsentHandler | null, persistentSettings?: Settings | null): void;
+/** Test-only: clear consent cache + handler. Never call from production code. */
+export declare function __resetAutoQaConsentForTests(): void;
+/**
+ * Resolve the user's consent for `report_tool_issue` grievances.
+ *
+ * Precedence (highest first):
+ *   1. Process-global cache (set on first successful resolution).
+ *   2. Persistent setting (`dev.autoqa.consent` on the supplied `Settings`).
+ *   3. Persistent setting on the registered host `Settings`.
+ *   4. Consent handler popup (single-flight; persists the answer).
+ *   5. Default-deny when no handler is registered.
+ *
+ * Never throws — handler errors degrade to "denied for this call" without
+ * caching, so a subsequent invocation can re-prompt instead of being
+ * permanently locked into the false branch.
+ */
+export declare function resolveAutoQaConsent(settings: Settings | undefined): Promise<boolean>;
+export declare function getAutoQaDbPath(): string;
+/**
+ * Open (or return the cached handle for) the auto-QA SQLite database at
+ * `~/.omp/agent/autoqa.db`. Idempotently runs schema creation, the
+ * `pushed`-column migration, and index setup so every consumer — tool
+ * execute path, manual `omp grievances push`, future debug scripts —
+ * sees the same prepared schema. Returns `null` only on a hard open
+ * failure (filesystem permissions, etc.); a missing file is created.
+ *
+ * Exported because the `omp grievances` CLI handlers need the migrated
+ * handle too — having a second `openDb` in the CLI led to the column
+ * never being added on the manual-push path.
+ */
+export declare function openAutoQaDb(): Database | null;
+export interface FlushResult {
+    pushed: number;
+    ok: boolean;
+    skipped?: boolean;
+}
+/**
+ * Optional per-flush controls. Used by `omp grievances push` to surface
+ * progress to a TTY and to skip the user-facing consent gate (manual
+ * pushes are the user's explicit intent, not a side effect of a tool call).
+ */
+export interface FlushOptions {
+    /**
+     * Skip the `dev.autoqa.consent === "granted"` gate in
+     * {@link resolvePushConfig}. Endpoint configuration is still required.
+     * Reserved for explicit user-driven pushes (CLI `grievances push`,
+     * future debug recipes); never set from the tool's auto-flush path.
+     */
+    bypassConsent?: boolean;
+    /**
+     * Fires once at the start of the loop with the snapshot count of
+     * unpushed rows. Subsequent inserts won't be reflected (the count is
+     * a planning hint for progress reporters, not a live total).
+     */
+    onStart?: (totalUnpushed: number) => void;
+    /**
+     * Fires after every successfully shipped batch with the running pushed
+     * count. Reporters compare against the `totalUnpushed` they saw in
+     * `onStart` to advance their bar.
+     */
+    onProgress?: (pushedSoFar: number) => void;
+}
+/** Test-only: clear single-flight + cooldown state. Never call from production code. */
+export declare function __resetAutoQaFlushStateForTests(): void;
+/**
+ * Flush queued grievances to the configured backend.
+ *
+ * Single-flight: concurrent callers share the in-flight promise. After a
+ * failed push, retries are skipped for {@link FAILURE_COOLDOWN_MS} ms.
+ * Never throws — all errors are caught and routed to the logger.
+ */
+export declare function flushGrievances(db?: Database, settings?: Settings, options?: FlushOptions): Promise<FlushResult>;
+export declare function createReportToolIssueTool(session: ToolSession, activeBuiltinNames?: readonly string[]): AgentTool;

package/dist/types/tools/resolve.d.ts

@@ -0,0 +1,85 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+declare const resolveSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        apply: "apply";
+        discard: "discard";
+    }>;
+    reason: z.ZodString;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ResolveParams = z.infer<typeof resolveSchema>;
+export interface ResolveToolDetails {
+    action: "apply" | "discard";
+    reason: string;
+    extra?: Record<string, unknown>;
+    sourceToolName?: string;
+    label?: string;
+    sourceResultDetails?: unknown;
+}
+/**
+ * Queue a resolve-protocol handler on the tool-choice queue. Forces the next
+ * LLM call to invoke the hidden `resolve` tool, wraps the caller's apply/reject
+ * callbacks into an onInvoked closure that matches the resolve schema, and
+ * steers a preview reminder so the model understands why.
+ *
+ * This is the canonical entry point for any tool that wants preview/apply
+ * semantics. No session-level abstraction is needed: callers pass their
+ * apply/reject functions directly.
+ */
+export declare function queueResolveHandler(session: ToolSession, options: {
+    label: string;
+    sourceToolName: string;
+    apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+}): void;
+/**
+ * Shared invocation runner used by both queued (in-flight) handlers and
+ * standing handlers (e.g. plan-mode approval). Discriminates on action,
+ * routes through the caller's apply/reject, and wraps the resulting tool
+ * payload with `ResolveToolDetails` so the renderer and event-controller
+ * see a consistent shape.
+ */
+export declare function runResolveInvocation(params: ResolveParams, options: {
+    sourceToolName: string;
+    label: string;
+    apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+}): Promise<AgentToolResult<ResolveToolDetails>>;
+export declare class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
+    private readonly session;
+    readonly name = "resolve";
+    readonly label = "Resolve";
+    readonly hidden = true;
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        action: z.ZodEnum<{
+            apply: "apply";
+            discard: "discard";
+        }>;
+        reason: z.ZodString;
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly intent: (args: Partial<ResolveParams>) => string;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: ResolveParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ResolveToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<ResolveToolDetails>>;
+}
+export declare const resolveToolRenderer: {
+    renderCall(args: ResolveParams, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: ResolveToolDetails;
+        isError?: boolean;
+    }, _options: RenderResultOptions, uiTheme: Theme): Component;
+    inline: boolean;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/review.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Review tools - report_finding for structured code review.
+ *
+ * Used by the reviewer agent to report findings in a structured way.
+ * Hidden by default - only enabled when explicitly listed in agent's tools.
+ * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
+ */
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
+export type FindingPriority = "P0" | "P1" | "P2" | "P3";
+export interface FindingPriorityInfo {
+    ord: 0 | 1 | 2 | 3;
+    symbol: "status.error" | "status.warning" | "status.info";
+    color: ThemeColor;
+}
+export declare const PRIORITY_LABELS: FindingPriority[];
+export declare function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo;
+declare const ReportFindingParams: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    priority: z.ZodEnum<{
+        P0: "P0";
+        P1: "P1";
+        P2: "P2";
+        P3: "P3";
+    }>;
+    confidence: z.ZodNumber;
+    file_path: z.ZodString;
+    line_start: z.ZodNumber;
+    line_end: z.ZodNumber;
+}, z.core.$strict>;
+interface ReportFindingDetails {
+    title: string;
+    body: string;
+    priority: FindingPriority;
+    confidence: number;
+    file_path: string;
+    line_start: number;
+    line_end: number;
+}
+export declare function parseReportFindingDetails(value: unknown): ReportFindingDetails | undefined;
+export declare const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme>;
+/** SubmitReviewDetails - used for rendering review results from yield tool */
+export interface SubmitReviewDetails {
+    overall_correctness: "correct" | "incorrect";
+    explanation: string;
+    confidence: number;
+}
+export type { ReportFindingDetails };

package/dist/types/tools/search-tool-bm25.d.ts

@@ -0,0 +1,65 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { type DiscoverableTool } from "../tool-discovery/tool-index";
+import type { ToolSession } from ".";
+export type { DiscoverableMCPSearchIndex, DiscoverableMCPTool, } from "../mcp/discoverable-tool-metadata";
+declare const searchToolBm25Schema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SearchToolBm25Params = z.infer<typeof searchToolBm25Schema>;
+interface SearchToolBm25Match {
+    name: string;
+    label: string;
+    description: string;
+    server_name?: string;
+    mcp_tool_name?: string;
+    schema_keys: string[];
+    score: number;
+}
+export interface SearchToolBm25Details {
+    query: string;
+    limit: number;
+    total_tools: number;
+    activated_tools: string[];
+    active_selected_tools: string[];
+    tools: SearchToolBm25Match[];
+}
+export declare function renderSearchToolBm25Description(discoverableTools?: DiscoverableTool[]): string;
+/**
+ * SearchToolsTool — wire name `search_tool_bm25` (preserved for persisted session back-compat).
+ *
+ * When tools.discoveryMode === "all", this covers both MCP tools and built-in discoverable tools.
+ * When tools.discoveryMode === "mcp-only" or mcp.discoveryMode === true, only MCP tools are searched.
+ */
+export declare class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema, SearchToolBm25Details> {
+    private readonly session;
+    readonly name = "search_tool_bm25";
+    readonly label = "SearchTools";
+    readonly loadMode = "essential";
+    get description(): string;
+    readonly parameters: z.ZodObject<{
+        query: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): SearchToolBm25Tool | null;
+    execute(_toolCallId: string, params: SearchToolBm25Params, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<SearchToolBm25Details>, _context?: AgentToolContext): Promise<AgentToolResult<SearchToolBm25Details>>;
+}
+export declare const searchToolBm25Renderer: {
+    renderCall(args: SearchToolBm25Params, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SearchToolBm25Details;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme): Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};

package/dist/types/tools/search.d.ts

@@ -0,0 +1,90 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { type TruncationResult } from "../session/streaming-output";
+import type { ToolSession } from ".";
+import { type OutputMeta } from "./output-meta";
+declare const searchSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    paths: z.ZodArray<z.ZodString>;
+    i: z.ZodOptional<z.ZodBoolean>;
+    gitignore: z.ZodOptional<z.ZodBoolean>;
+    skip: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type SearchToolInput = z.infer<typeof searchSchema>;
+/** Maximum number of distinct files surfaced in a single response. The
+ * agent paginates further pages via `skip`. */
+export declare const DEFAULT_FILE_LIMIT = 20;
+/** Per-file match cap for multi-file searches — keeps a single hot file
+ * from crowding out diverse hits. Applied in JS after grep returns. */
+export declare const MULTI_FILE_PER_FILE_MATCHES = 20;
+/** Per-file match cap for single-file searches — there's no diversity
+ * concern when the scope is one file. */
+export declare const SINGLE_FILE_MATCHES = 200;
+export interface SearchToolDetails {
+    truncation?: TruncationResult;
+    fileLimitReached?: number;
+    perFileLimitReached?: number;
+    linesTruncated?: boolean;
+    meta?: OutputMeta;
+    scopePath?: string;
+    matchCount?: number;
+    fileCount?: number;
+    files?: string[];
+    fileMatches?: Array<{
+        path: string;
+        count: number;
+    }>;
+    truncated?: boolean;
+    error?: string;
+    /** Pre-formatted text for the user-visible TUI render. Mirrors the model-facing
+     * `result.text` lines but uses a `│` gutter and `*` to mark match lines (vs space for
+     * context). The TUI uses this directly so it never parses model-facing hashline anchors. */
+    displayContent?: string;
+    /** User-supplied paths whose base directory was missing on disk. The tool
+     * skipped these and continued with the surviving entries; surfaced as a
+     * non-fatal warning in the renderer and in the model-facing text. */
+    missingPaths?: string[];
+}
+type SearchParams = z.infer<typeof searchSchema>;
+export declare class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
+    private readonly session;
+    readonly name = "search";
+    readonly label = "Search";
+    readonly loadMode = "discoverable";
+    readonly summary = "Search file contents using ripgrep (fast text search)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        pattern: z.ZodString;
+        paths: z.ZodArray<z.ZodString>;
+        i: z.ZodOptional<z.ZodBoolean>;
+        gitignore: z.ZodOptional<z.ZodBoolean>;
+        skip: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: SearchParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<SearchToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<SearchToolDetails>>;
+}
+interface SearchRenderArgs {
+    pattern: string;
+    paths?: string[];
+    i?: boolean;
+    gitignore?: boolean;
+    skip?: number;
+}
+export declare const searchToolRenderer: {
+    inline: boolean;
+    renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SearchToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: SearchRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};