@oh-my-pi/pi-coding-agent 15.9.67 → 15.10.1

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

@@ -13,14 +13,6 @@ import type { EvalStatusEvent, EvalToolDetails } from "../eval/types";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 export declare const EVAL_DEFAULT_PREVIEW_LINES = 10;
-/**
- * Rows of source kept in the *pending* eval preview. The window follows the
- * streaming edge (newest lines pinned to the bottom) so you can watch the code
- * being written, while staying bounded — a volatile tool block taller than the
- * viewport would otherwise strand its scrolled-off head out of native scrollback
- * on ED3-risk terminals. Matches the streaming windows used by edit/write.
- */
-export declare const EVAL_STREAMING_PREVIEW_LINES = 12;
 interface EvalRenderCellArg {
     language?: string;
     code?: string;
@@ -54,6 +46,7 @@ export declare const evalToolRenderer: {
     }, options: RenderResultOptions & {
         renderContext?: EvalRenderContext;
     }, uiTheme: Theme, _args?: EvalRenderArgs): Component;
+    isStreamingPreviewAppendOnly(_args: EvalRenderArgs, _options: RenderResultOptions, result?: unknown): boolean;
     mergeCallAndResult: boolean;
     inline: boolean;
 };

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

@@ -17,14 +17,22 @@ export interface ParsedReadUrlTarget {
     ranges?: readonly LineRange[];
 }
 export declare function parseReadUrlTarget(readPath: string): ParsedReadUrlTarget | null;
+/** Reader backends for {@link renderHtmlToText}, in default priority order. */
+export type FetchProvider = "native" | "trafilatura" | "lynx" | "parallel" | "jina";
 /**
- * Render HTML to markdown using Parallel, jina, trafilatura, lynx, then the
- * in-process native converter. The overall `timeout` budget bounds the call,
- * but remote reader requests are additionally capped at `REMOTE_READER_MAX_MS`
- * so that a hung remote endpoint cannot prevent local fallbacks from running.
- * Only a real `userSignal` cancellation aborts the chain — remote per-attempt
- * timeouts and the overall reader-mode timeout still allow later renderers
- * (especially the purely-local native converter) to be tried.
+ * Render HTML to markdown by trying reader backends in priority order: native
+ * (in-process), trafilatura, lynx, Parallel, then Jina. The `providers.fetch`
+ * setting picks the order — `auto` uses the default above; any specific backend
+ * is tried first, then the remaining backends as fallbacks. Every backend's
+ * output must clear the same quality gate (>100 non-whitespace chars and not
+ * {@link isLowQualityOutput}) before it is accepted, otherwise the next backend
+ * is tried.
+ *
+ * The overall `timeout` budget bounds the whole call; remote backends (Parallel,
+ * Jina) are additionally capped at `REMOTE_READER_MAX_MS` so a hung endpoint
+ * cannot starve later renderers — especially the purely-local native converter,
+ * which always works on already-loaded HTML. Only a real `userSignal`
+ * cancellation aborts the chain (#1449).
  */
 export declare function renderHtmlToText(url: string, html: string, timeout: number, settings: Settings, userSignal: AbortSignal | undefined, storage: AgentStorage | null): Promise<{
     content: string;

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

@@ -15,10 +15,14 @@ declare const findSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type FindToolInput = z.infer<typeof findSchema>;
 /**
- * Group find matches by their directory so the model doesn't pay repeated
- * tokens for shared path prefixes. Preserves the input order: groups appear in
- * the order their first member was emitted (mtime-desc for native glob), and
- * within a group entries keep their relative order.
+ * Group find matches into a multi-level directory tree so the model doesn't pay
+ * repeated tokens for shared path prefixes. Single-child directory chains fold
+ * into one header (`# a/b/c/`), so a common prefix — including an absolute root
+ * for out-of-cwd results — collapses to a single line. Each level adds one `#`;
+ * files are listed bare under the deepest directory header that owns them.
+ *
+ * Order follows the input (mtime-desc for native glob): a directory appears when
+ * its first member is emitted, and a node's own files precede its subdirectories.
  */
 export declare function formatFindGroupedOutput(paths: readonly string[]): string;
 export interface FindToolDetails {

package/dist/types/tools/grouped-file-output.d.ts

@@ -1,7 +1,55 @@
+interface PathTreeNode {
+    /** Direct file leaves, in first-seen order. */
+    files: Array<{
+        name: string;
+        key: string;
+    }>;
+    /** Dedup set for `files` (a glob can surface the same path twice on retry). */
+    fileNames: Set<string>;
+    /** Child directories, in first-seen order. */
+    subdirs: Array<{
+        name: string;
+        node: PathTreeNode;
+    }>;
+    /** Dedup index for `subdirs`. */
+    dirIndex: Map<string, PathTreeNode>;
+}
+export interface PathTreeInput {
+    /** Path string; absolute, cwd-relative, or url-like. Backslashes are normalized. */
+    path: string;
+    /** Whether the leaf itself is a directory (trailing-slash match from find). */
+    isDir: boolean;
+    /** Opaque key carried onto file events for section lookup. Defaults to `path`. */
+    key?: string;
+}
+/** One node emitted while walking the tree: a folded directory or a file leaf. */
+export interface GroupedTreeEvent {
+    kind: "dir" | "file";
+    /** 0-based nesting depth (root children are depth 0). */
+    depth: number;
+    /** Folded chain for dirs (e.g. `a/b/c`, no trailing slash); basename for files. */
+    name: string;
+    /** File key for `kind === "file"`; empty string for directories. */
+    key: string;
+}
+/**
+ * Build a directory tree from a flat list of paths. URL-like entries are kept
+ * whole as root-level file leaves (they have no meaningful directory structure).
+ * Absolute paths carry a leading empty segment so they share a common `/` root
+ * and fold like any other prefix.
+ */
+export declare function buildPathTree(entries: Iterable<PathTreeInput>): PathTreeNode;
+/**
+ * Depth-first walk yielding directory and file events. Directories collapse their
+ * single-child chains (`a` → `a/b` → `a/b/c`) so a shared prefix becomes one
+ * header. Each node's direct files are emitted before its subdirectories, keeping
+ * a file unambiguously attached to the header above it.
+ */
+export declare function walkPathTree(node: PathTreeNode, depth?: number): Generator<GroupedTreeEvent>;
 /**
  * One file's contribution to a grouped file output. The header itself is generated
- * by `formatGroupedFiles` (single `#` for root files, `##` for files inside a dir);
- * use `headerSuffix` to tack on extras like ` (1 replacement)`.
+ * by `formatGroupedFiles` (one `#` per nesting level); use `headerSuffix` to tack
+ * on extras like ` (1 replacement)`.
  */
 export interface GroupedFileSection {
     /** Optional suffix appended to the file header. */
@@ -18,19 +66,54 @@ export interface GroupedFilesOutput {
     display: string[];
 }
 /**
- * Render a list of files as directory-grouped sections shared by grep, ast-grep,
- * ast-edit, and the LSP diagnostic formatter.
+ * Render a list of files as a multi-level, prefix-folded directory tree shared by
+ * grep, ast-grep, ast-edit, and the LSP diagnostic formatter.
  *
- * Layout:
- *   # dir/
- *   ## file.ts
+ * Layout (one `#` per level; the shared prefix folds into the top header):
+ *   # packages/pkg/src/
+ *   ## root.ts
  *   …body…
- *
- *   # otherdir/
- *   ## other.ts
+ *   ## nested/
+ *   ### child.ts
  *   …body…
  *
- * Files in the project root (directory `.`) become single-`#` headers without a
- * `## file` line, matching the existing convention.
+ * Files in the (folded) project root become single-`#` headers with no parent
+ * directory line. A blank line precedes every directory header and every
+ * root-level file so the renderers can split the output into collapsible groups.
  */
 export declare function formatGroupedFiles(files: string[], renderFile: (filePath: string) => GroupedFileSection): GroupedFilesOutput;
+/** Per-line classification of grouped output, used by renderers for hyperlinks. */
+export interface GroupedLineContext {
+    /** Directory header, file header, or any non-header body/content line. */
+    kind: "dir" | "file" | "content";
+    /** Number of leading `#` for headers; 0 for content lines. */
+    depth: number;
+    /** Resolved absolute path of the dir/file a header points at (when resolvable). */
+    headerPath?: string;
+    /** For content lines, the absolute path of the owning file (line hyperlinks). */
+    filePath?: string;
+    /** Header is an internal/url-like target the caller resolves itself. */
+    isUrl?: boolean;
+}
+/**
+ * Walk grouped output lines, tracking a directory stack keyed by header depth, so
+ * each header and body line can be linked back to its absolute filesystem path.
+ * Reconstruction is stack-based (not per-blank-group) so nested directory headers
+ * resolve correctly across the whole output.
+ *
+ * `headerBase` is the directory the displayed (folded) header paths are relative
+ * to — for grep/ast tools that is the session cwd, since display paths are
+ * formatted relative to cwd regardless of the (sub)directory the search was
+ * scoped to. `fileScope` is the initial owning file for body lines that appear
+ * before any header (single-file scopes have no `#` headers); it defaults to
+ * `headerBase` and should be passed the scoped file's absolute path.
+ */
+export declare function classifyGroupedLines(lines: readonly string[], headerBase: string | undefined, fileScope?: string | undefined): GroupedLineContext[];
+/**
+ * Split line indices into blank-line-separated groups, mirroring
+ * `splitGroupsByBlankLine`: when any blank line is present, break on runs of
+ * blanks; otherwise return a single group of the non-empty lines. Returning
+ * indices lets callers slice parallel arrays (raw lines, styled lines, contexts).
+ */
+export declare function groupLineIndicesByBlank(rawLines: readonly string[]): number[][];
+export {};

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

@@ -4,7 +4,10 @@
  *
  * These keep the transcript terse — one status line plus, for `retain`, one
  * `Remember: …` line per stored item — instead of the generic JSON arg tree,
- * which exploded multi-line memory blobs into an unreadable wall.
+ * which exploded multi-line memory blobs into an unreadable wall. The tool
+ * container is a transparent passthrough, so these renderers stay frameless:
+ * a status line with a couple of dim bullets reads far cleaner than boxing a
+ * one-line memory note.
  */
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";

package/dist/types/tools/plan-mode-guard.d.ts

@@ -1,16 +1,15 @@
 import type { ToolSession } from ".";
 /**
- * Resolve a write/edit target to its absolute filesystem path.
- *
- * In plan mode, transparently redirects `PLAN.md` aliases and targets whose
- * basename matches the plan file's basename to the canonical plan file
- * location at `state.planFilePath`. This lets `write` and `edit` accept the
- * habitual plan filename after approval even when the active artifact has a
- * titled path such as `local://APPROVED.md`.
- *
- * Outside plan mode (or when the basename does not match) this is a no-op.
+ * Resolve a write/edit target to its absolute filesystem path, honoring the
+ * `local://` and `vault://` schemes. Plain paths resolve against the session cwd.
  */
 export declare function resolvePlanPath(session: ToolSession, targetPath: string): string;
+/**
+ * Plan mode keeps the working tree read-only while letting the agent draft its
+ * plan. Writes and edits to the `local://` artifact sandbox are allowed (that is
+ * where the plan and any scratch notes live); anything that would touch the
+ * working tree — or rename/delete a file — is rejected.
+ */
 export declare function enforcePlanModeWrite(session: ToolSession, targetPath: string, options?: {
     move?: string;
     op?: "create" | "update" | "delete";

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

@@ -46,8 +46,8 @@ export declare const TRUNCATE_LENGTHS: {
     /** Very short (task previews, badges) */
     readonly SHORT: 40;
 };
-/** Standard expand hint text */
-export declare const EXPAND_HINT = "(Ctrl+O for more)";
+/** Human-readable key currently bound to tool-output expansion, e.g. `Ctrl+O`. */
+export declare function expandKeyHint(): string;
 /**
  * Get first N lines of text as preview, with each line truncated.
  */
@@ -103,6 +103,14 @@ export declare function capPreviewLines(lines: string[], theme: Theme, options?:
 }): string[];
 export declare function formatMeta(meta: string[], theme: Theme): string;
 export declare function formatErrorMessage(message: string | undefined, theme: Theme): string;
+/**
+ * Error message rendered as a subordinate detail line beneath a status header
+ * that already carries the error icon (e.g. `✘ Write: <path>`). The header's
+ * icon already signals failure, so this omits the redundant error symbol and
+ * "Error:" prefix that `formatErrorMessage` adds for standalone single-line
+ * errors, indenting two columns to sit under the header title instead.
+ */
+export declare function formatErrorDetail(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;
@@ -155,18 +163,14 @@ export declare function capParseErrors(errors: string[] | undefined, limit?: num
     errors: string[];
     total: number;
 };
-/**
- * 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;
+export declare function createCachedComponent(getExpanded: () => boolean, compute: (width: number, expanded: boolean) => string[], options?: {
+    paddingX?: number;
+}): Component;
 /**
  * Append the indented bullet list of parse errors (capped at
  * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the

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

@@ -6,7 +6,7 @@
 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 = {
+export type ToolRenderer = {
     renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
     renderResult: (result: {
         content: Array<{
@@ -19,8 +19,22 @@ type ToolRenderer = {
         renderContext?: Record<string, unknown>;
     }, theme: Theme, args?: unknown) => Component;
     mergeCallAndResult?: boolean;
+    /**
+     * While a tool's preview is still streaming, report whether the
+     * currently-rendered preview is append-only: its rows only grow at the bottom
+     * and never re-layout above the bottom live region (a full, top-anchored
+     * content/code preview). The transcript reports this up to the TUI so a
+     * streaming preview taller than the viewport commits its scrolled-off head to
+     * native scrollback instead of dropping it (see
+     * `ToolExecutionComponent.isTranscriptBlockAppendOnly`). `result` is the
+     * latest (possibly partial) tool result, or `undefined` before one exists —
+     * `eval`/`bash` use its presence to defer committing until the streamed input
+     * (code) has finalized. Omit (or return `false`) for previews that slide a
+     * tail window or later collapse to a compact result — committing their head
+     * would strand stale rows.
+     */
+    isStreamingPreviewAppendOnly?: (args: unknown, options: RenderResultOptions, result?: unknown) => boolean;
     /** Render without background box, inline in the response flow */
     inline?: boolean;
 };
 export declare const toolRenderers: Record<string, ToolRenderer>;
-export {};

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

@@ -5,7 +5,7 @@ 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";
+import type { OutputMeta } from "./output-meta";
 declare const searchSchema: z.ZodObject<{
     pattern: z.ZodString;
     paths: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
@@ -47,6 +47,10 @@ export interface SearchToolDetails {
     /** Absolute base directory used during search. Used by the renderer to resolve
      * display-relative paths to absolute paths for OSC 8 hyperlinks. */
     searchPath?: string;
+    /** Session cwd at search time. The renderer resolves the display-relative
+     * (cwd-relative) header/match paths against this for OSC 8 hyperlinks;
+     * `searchPath` is the scope label target, not the display-path base. */
+    cwd?: 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. */

package/dist/types/tools/sqlite-reader.d.ts

@@ -1,4 +1,5 @@
 import type { Database } from "bun:sqlite";
+export declare function looksLikeSqlite(bytes: Uint8Array): boolean;
 export interface SqlitePathCandidate {
     sqlitePath: string;
     subPath: string;

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

@@ -146,14 +146,15 @@ export declare const TODO_STRIKE_HOLD_FRAMES = 2;
 export declare const TODO_STRIKE_REVEAL_FRAMES = 12;
 export declare const TODO_STRIKE_TOTAL_FRAMES: number;
 export declare const todoToolRenderer: {
-    renderCall(args: TodoRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{
             type: string;
             text?: string;
         }>;
         details?: TodoToolDetails;
-    }, options: RenderResultOptions, uiTheme: Theme, _args?: TodoRenderArgs): Component;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: TodoRenderArgs): Component;
     mergeCallAndResult: boolean;
 };
 export {};

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

@@ -17,6 +17,9 @@ export interface WriteToolDetails {
     meta?: OutputMeta;
     /** Set when the file was auto-chmod'd because content begins with a `#!` shebang. */
     madeExecutable?: boolean;
+    /** Absolute filesystem path the write resolved to. Used by the renderer to wrap
+     * the (possibly cwd-relative) header path in an OSC 8 `file://` hyperlink. */
+    resolvedPath?: string;
 }
 type WriteParams = WriteToolInput;
 /**
@@ -53,12 +56,14 @@ interface WriteRenderArgs {
 }
 export declare const writeToolRenderer: {
     renderCall(args: WriteRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    isStreamingPreviewAppendOnly(args: WriteRenderArgs, options: RenderResultOptions, _result?: unknown): boolean;
     renderResult(result: {
         content: Array<{
             type: string;
             text?: string;
         }>;
         details?: WriteToolDetails;
+        isError?: boolean;
     }, options: RenderResultOptions, uiTheme: Theme, args?: WriteRenderArgs): Component;
     mergeCallAndResult: boolean;
 };

package/dist/types/tui/output-block.d.ts

@@ -2,7 +2,7 @@
  * Bordered output container with optional header and sections.
  */
 import type { Component } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../modes/theme/theme";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
 import type { State } from "./types";
 export interface OutputBlockOptions {
     header?: string;
@@ -11,11 +11,16 @@ export interface OutputBlockOptions {
     sections?: Array<{
         label?: string;
         lines: string[];
+        separator?: boolean;
     }>;
     width: number;
     applyBg?: boolean;
+    contentPaddingLeft?: number;
     /** Animate the border with a sweeping dark segment (pending/running state). */
     animate?: boolean;
+    /** Override the state-derived border color. Used for muted "legacy" tool
+     * frames that should not visually compete with framed-output tools. */
+    borderColor?: ThemeColor;
 }
 declare const FRAMED_BLOCK_COMPONENT: unique symbol;
 export type FramedBlockComponent = Component & {
@@ -24,9 +29,9 @@ export type FramedBlockComponent = Component & {
 export declare function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent;
 export declare function isFramedBlockComponent(component: Component): boolean;
 /**
- * Monotonic frame counter for animated borders, quantized to the TUI's ~16ms
- * render cap so the cache key advances once per ~60fps frame — fine enough for a
- * smooth segment sweep, coarse enough to coalesce multiple render passes that
+ * Monotonic frame counter for animated borders, quantized to the TUI's ~30fps
+ * render cap so the cache key advances once per animation frame — fine enough
+ * for a smooth segment sweep, coarse enough to coalesce multiple render passes
  * land inside the same frame.
  */
 export declare function borderShimmerTick(): number;
@@ -54,4 +59,11 @@ export declare class CachedOutputBlock {
     /** Invalidate the cache, forcing a rebuild on next render. */
     invalidate(): void;
 }
+/**
+ * Build a self-framing tool component backed by a cached output block. The
+ * `build` callback returns the block options for a given width; the cache
+ * dedupes re-renders. Pass `borderColor: "borderMuted"` for the dim "legacy"
+ * look that does not compete with the state-colored framed tools.
+ */
+export declare function framedBlock(theme: Theme, build: (width: number) => OutputBlockOptions): Component;
 export {};

package/dist/types/tui/status-line.d.ts

@@ -5,6 +5,9 @@ import type { Theme, ThemeColor } from "../modes/theme/theme";
 import type { ToolUIStatus } from "../tools/render-utils";
 export interface StatusLineOptions {
     icon?: ToolUIStatus;
+    /** Pre-rendered glyph that replaces the status icon (e.g. a magnifier for
+     * search-family tools). Takes precedence over `icon`. */
+    iconOverride?: string;
     spinnerFrame?: number;
     title: string;
     titleColor?: ThemeColor;

package/dist/types/utils/enhanced-paste.d.ts

@@ -0,0 +1,20 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+export interface Osc5522Packet {
+    metadata: Map<string, string>;
+    payload: string;
+}
+export interface EnhancedPasteHandlers {
+    write(data: string): void;
+    pasteText(text: string): void;
+    pasteImage(image: ImageContent): void | Promise<void>;
+    showStatus(message: string): void;
+}
+export declare function isOsc5522Packet(data: string): boolean;
+export declare function parseOsc5522Packet(data: string): Osc5522Packet | undefined;
+export declare class EnhancedPasteController {
+    #private;
+    constructor(handlers: EnhancedPasteHandlers);
+    enable(): void;
+    disable(): void;
+    handleInput(data: string): boolean;
+}

package/dist/types/web/scrapers/github.d.ts

@@ -1,4 +1,18 @@
 import type { SpecialHandler } from "./types";
+interface GitHubUrl {
+    type: "blob" | "tree" | "repo" | "issue" | "issues" | "pull" | "pulls" | "discussion" | "discussions" | "actions-run" | "actions-job" | "other";
+    owner: string;
+    repo: string;
+    ref?: string;
+    path?: string;
+    number?: number;
+    runId?: number;
+    jobId?: number;
+}
+/**
+ * Parse GitHub URL into components
+ */
+export declare function parseGitHubUrl(url: string): GitHubUrl | null;
 /**
  * Fetch from GitHub API
  */
@@ -6,7 +20,15 @@ export declare function fetchGitHubApi(endpoint: string, timeout: number, signal
     data: unknown;
     ok: boolean;
 }>;
+/**
+ * Strip the per-line ISO-8601 timestamp prefix GitHub prepends to every job log line.
+ * Cuts ~28 bytes/line of noise while preserving the message text. Also drops the leading
+ * UTF-8 BOM GitHub puts at the start of the log file (otherwise the first line's timestamp
+ * survives because `^` no longer sits before a digit).
+ */
+export declare function stripActionsLogTimestamps(logs: string): string;
 /**
  * Handle GitHub URLs specially
  */
 export declare const handleGitHub: SpecialHandler;
+export {};

package/dist/types/web/search/providers/kimi.d.ts

@@ -4,7 +4,7 @@
  * Uses Moonshot Kimi Code search API to retrieve web results.
  * Endpoint: POST https://api.kimi.com/coding/v1/search
  */
-import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import { type AuthStorage } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";

package/dist/types/web/search/providers/perplexity.d.ts

@@ -1,10 +1,11 @@
 /**
  * Perplexity Web Search Provider
  *
- * Supports three auth modes:
+ * Supports four auth modes:
  * - Cookies (`PERPLEXITY_COOKIES`) via `www.perplexity.ai/rest/sse/perplexity_ask`
  * - OAuth/session bearer via `AuthStorage` and `www.perplexity.ai/rest/sse/perplexity_ask`
  * - API key (`PERPLEXITY_API_KEY`) via `api.perplexity.ai/chat/completions`
+ * - Anonymous via `www.perplexity.ai/rest/sse/perplexity_ask`
  */
 import { type AuthStorage } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
@@ -34,5 +35,11 @@ export declare class PerplexityProvider extends SearchProvider {
     readonly id = "perplexity";
     readonly label = "Perplexity";
     isAvailable(authStorage: AuthStorage): boolean;
+    /**
+     * Perplexity accepts anonymous browser-style ask requests, but keep auto
+     * provider selection credential-gated so a configured provider keeps priority
+     * over the anonymous fallback.
+     */
+    isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
     search(params: SearchParams): Promise<SearchResponse>;
 }

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

@@ -18,7 +18,7 @@ export declare const SEARCH_PROVIDER_OPTIONS: readonly [{
 }, {
     readonly value: "perplexity";
     readonly label: "Perplexity";
-    readonly description: "Requires PERPLEXITY_COOKIES or PERPLEXITY_API_KEY";
+    readonly description: "Uses auth when configured; explicit selection falls back to anonymous search";
 }, {
     readonly value: "brave";
     readonly label: "Brave";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.9.67",
+	"version": "15.10.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,14 +47,14 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.9.67",
-		"@oh-my-pi/omp-stats": "15.9.67",
-		"@oh-my-pi/pi-agent-core": "15.9.67",
-		"@oh-my-pi/pi-ai": "15.9.67",
-		"@oh-my-pi/pi-mnemopi": "15.9.67",
-		"@oh-my-pi/pi-natives": "15.9.67",
-		"@oh-my-pi/pi-tui": "15.9.67",
-		"@oh-my-pi/pi-utils": "15.9.67",
+		"@oh-my-pi/hashline": "15.10.1",
+		"@oh-my-pi/omp-stats": "15.10.1",
+		"@oh-my-pi/pi-agent-core": "15.10.1",
+		"@oh-my-pi/pi-ai": "15.10.1",
+		"@oh-my-pi/pi-mnemopi": "15.10.1",
+		"@oh-my-pi/pi-natives": "15.10.1",
+		"@oh-my-pi/pi-tui": "15.10.1",
+		"@oh-my-pi/pi-utils": "15.10.1",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/dev-launch

@@ -0,0 +1,42 @@
+#!/bin/sh
+# Dev launcher for the omp CLI, installed by `bun run install:dev`.
+#
+# Problem it solves: Bun reads `bunfig.toml` from the *current working
+# directory* at startup and evaluates its `preload` entries before running the
+# script. A bun-shebang bin (what `bun link` creates for `src/cli.ts`)
+# therefore inherits whatever `preload` the directory you happen to be in
+# declares. Running `omp`/`pi` inside an unrelated Bun project can execute — and
+# crash on — that project's preload, e.g.
+#   error: Cannot find module '@v12sh/utils/frontmatter' from '.../loader.ts'
+#
+# Bun only reads the *exact* cwd (it does not walk parents) and ignores
+# `--config`/`BUN_BE_BUN` for this, so the fix is to launch Bun from an empty,
+# bunfig-free directory and restore the real cwd inside the process via the
+# preload shim alongside this file.
+set -e
+
+# Resolve this script's real location even when invoked through a symlink
+# (`$HOME/.bun/bin/omp` -> this file).
+self=$0
+while [ -L "$self" ]; do
+	link=$(readlink "$self")
+	case $link in
+	/*) self=$link ;;
+	*) self=$(dirname "$self")/$link ;;
+	esac
+done
+scripts_dir=$(CDPATH= cd -- "$(dirname -- "$self")" && pwd -P)
+cli=$scripts_dir/../src/cli.ts
+preload=$scripts_dir/dev-launch-preload.ts
+timing_preload=$scripts_dir/../../utils/src/module-timer.ts
+
+launch_dir=${OMP_DEV_LAUNCH_DIR:-${HOME}/.omp/.dev-cwd}
+mkdir -p "$launch_dir"
+
+OMP_LAUNCH_CWD=$PWD
+export OMP_LAUNCH_CWD
+cd "$launch_dir"
+if [ -n "${PI_TIMING:-}" ]; then
+	exec bun --preload "$preload" --preload "$timing_preload" "$cli" "$@"
+fi
+exec bun --preload "$preload" "$cli" "$@"