@oh-my-pi/pi-coding-agent 16.1.12 → 16.1.14

package/dist/types/subprocess/worker-client.d.ts

@@ -0,0 +1,149 @@
+import type { Subprocess } from "bun";
+/**
+ * Shared lifecycle scaffolding for the ONNX inference subprocess clients
+ * (mnemopi embeddings, speech-to-text, tiny-model titles/completions, TTS).
+ * Each runs `onnxruntime-node` inside a dedicated Bun child process so the NAPI
+ * constructor/finalizer never executes in the main agent address space — those
+ * destructors segfault Bun on shutdown (issues #1606 / #1607 / #3031).
+ *
+ * Only the genuinely identical pieces live here: the worker-handle shape, the
+ * spawn-command resolution, the parent-env snapshot, the `Bun.spawn` wiring,
+ * the inline "worker unavailable" stub, and the ping/pong smoke probe. Each
+ * client keeps its own divergent request/response correlation, streaming, and
+ * teardown semantics.
+ */
+/** Minimal inbound contract shared by every worker: a correlated `ping`. */
+export type WorkerInboundBase = {
+    type: "ping";
+    id: string;
+};
+/** Structured log line forwarded from a worker to the parent logger. */
+export type WorkerLogMessage = {
+    type: "log";
+    level: "debug" | "warn" | "error";
+    msg: string;
+    meta?: Record<string, unknown>;
+};
+/** Minimal outbound contract shared by every worker: `pong`, `error`, `log`. */
+export type WorkerOutboundBase = {
+    type: "pong";
+    id: string;
+} | {
+    type: "error";
+    id: string;
+    error: string;
+} | WorkerLogMessage;
+/**
+ * Parent-side view of a worker subprocess: send typed inbound messages,
+ * subscribe to outbound messages and worker errors, and hard-terminate.
+ */
+export interface WorkerHandle<Inbound, Outbound> {
+    send(message: Inbound): void;
+    onMessage(handler: (message: Outbound) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    terminate(): Promise<void>;
+}
+/**
+ * A {@link WorkerHandle} that can also be (un)referenced so a pending request
+ * keeps the parent event loop alive while an idle worker never blocks exit.
+ */
+export interface RefCountedWorkerHandle<Inbound, Outbound> extends WorkerHandle<Inbound, Outbound> {
+    /** Re-reference the subprocess so a pending request keeps the parent event loop alive. */
+    ref(): void;
+    /** Drop the reference once the worker is idle so it never blocks process exit. */
+    unref(): void;
+}
+/** The raw spawned subprocess plus the parent-side fan-out sets. */
+export interface SpawnedSubprocess<Outbound> {
+    proc: Subprocess<"ignore", "ignore", "ignore">;
+    inbound: Set<(message: Outbound) => void>;
+    errors: Set<(error: Error) => void>;
+    /**
+     * Flipped to `true` right before the deliberate SIGKILL so `onExit` can
+     * distinguish the expected hard-kill from a crash (SIGSEGV from a native
+     * fault, OOM SIGKILL, operator `kill -9`). Only the latter surfaces as a
+     * worker error so callers don't await forever.
+     */
+    intentionalExit: {
+        value: boolean;
+    };
+}
+export interface WorkerSpawnCommand {
+    cmd: string[];
+    cwd?: string;
+}
+/**
+ * Cold-starting a worker from a compiled binary (decompress + module graph
+ * load) is slow on contended CI runners; the probe only proves the worker
+ * spawns and ponges, so a generous bound removes flakes without weakening it.
+ */
+export declare const SMOKE_TEST_TIMEOUT_MS = 30000;
+/**
+ * Resolve the command used to relaunch the agent CLI into worker mode. In a
+ * compiled binary the entry point is the binary itself; otherwise re-enter the
+ * declared worker-host entry with a cwd-relative script path (Bun's subprocess
+ * IPC is more reliable that way under `bun test`), falling back to this
+ * package's own `src/cli.ts` when no host entry is declared (bun test, SDK
+ * embedding).
+ */
+export declare function resolveWorkerSpawnCmd(workerArg: string): WorkerSpawnCommand;
+/**
+ * Snapshot the parent environment for the child. `process.env` carries
+ * `undefined` slots that `Bun.spawn` rejects, so filter them out; an optional
+ * `overlay` (e.g. the tiny-model device/dtype vars) wins over inherited keys.
+ */
+export declare function workerEnvFromParent(overlay?: Record<string, string>): Record<string, string>;
+/**
+ * Spawn an inference worker subprocess and wire its IPC fan-out. The child
+ * inherits no stdio (native model runtimes may otherwise print progress or
+ * decoded text and corrupt the chat scrollback) and is `unref`'d outside `bun
+ * test` so an idle worker never blocks process exit. `exitLabel` prefixes the
+ * worker-error message surfaced for an unexpected (non-intentional) exit.
+ */
+export declare function createWorkerSubprocess<Outbound>(options: {
+    spawnCommand: WorkerSpawnCommand;
+    env: Record<string, string>;
+    exitLabel: string;
+}): SpawnedSubprocess<Outbound>;
+/**
+ * Wrap a {@link SpawnedSubprocess} as a {@link WorkerHandle}. The `send`
+ * strategy is injected so each client keeps its exact IPC-send behaviour (e.g.
+ * `safeSend` vs an inline guarded `proc.send`). `terminate()` SIGKILLs: the
+ * point of subprocess isolation is that the parent never runs
+ * `onnxruntime-node`'s NAPI finalizer (it crashes Bun on Windows), so the OS
+ * reclaims the model memory instead. The intentional-exit flag is flipped
+ * *before* the kill so `onExit` can tell it apart from a native crash.
+ */
+export declare function createWorkerHandle<Inbound, Outbound>(spawned: SpawnedSubprocess<Outbound>, send: (message: Inbound) => void): WorkerHandle<Inbound, Outbound>;
+/**
+ * A stand-in handle used when the worker subprocess cannot be spawned. It
+ * ponges `ping` (so the smoke probe and readiness checks still resolve) and
+ * answers every other request with the spawn error so callers fail fast
+ * instead of awaiting forever.
+ */
+export declare function createUnavailableWorker<Inbound extends {
+    type: string;
+    id: string;
+}, Outbound extends {
+    type: string;
+}>(error: unknown): WorkerHandle<Inbound, Outbound>;
+/**
+ * Spawn a worker handle, falling back to {@link createUnavailableWorker} (after
+ * a warning) when the subprocess cannot be created so the feature degrades
+ * gracefully instead of throwing into callers.
+ */
+export declare function spawnWorkerOrUnavailable<Handle>(spawn: () => Handle, unavailable: (error: unknown) => Handle, warnMessage: string): Handle;
+/** Forward a worker's structured `log` message to the matching logger level. */
+export declare function logWorkerMessage(message: WorkerLogMessage): void;
+/**
+ * Drive the ping/pong readiness probe wired into `omp --smoke-test`: send one
+ * `ping`, resolve on the first `pong` (ignoring `log` chatter), and reject on
+ * any other message, a worker error, or the timeout. Always tears the handle
+ * down on the way out. `label` prefixes the failure messages.
+ */
+export declare function smokeTestWorker<Inbound extends {
+    type: string;
+    id: string;
+}, Outbound extends {
+    type: string;
+}>(handle: WorkerHandle<Inbound, Outbound>, label: string, timeoutMs: number): Promise<void>;

package/dist/types/subprocess/worker-runtime.d.ts

@@ -0,0 +1,107 @@
+import type { ProgressInfo } from "@huggingface/transformers";
+/**
+ * Child-side scaffolding shared by the ONNX inference worker bodies
+ * (`stt/asr-worker`, `tiny/worker`, `tts/tts-worker`). These are the helpers
+ * that run inside the spawned subprocess: error serialization, structured log
+ * and progress reporting over the worker's typed transport, side-runtime
+ * install (sharp stubbing + module-resolver patch), once-per-process runtime
+ * memoization, and the Transformers.js runtime loader. The parent/client-side
+ * complement lives in `worker-client.ts`.
+ *
+ * Each worker keeps its own strongly-typed transport / model-key / progress
+ * event; the structural {@link WorkerLogTransport} / {@link WorkerProgressTransport}
+ * interfaces below are the minimal shapes these helpers need, and every worker's
+ * concrete transport satisfies them.
+ */
+export declare const TRANSFORMERS_PACKAGE = "@huggingface/transformers";
+export declare function errorText(error: unknown): string;
+export declare function errorMessage(error: unknown): string;
+export type WorkerLogLevel = "debug" | "warn" | "error";
+/** Minimal transport surface a worker exposes for forwarding log lines. */
+export interface WorkerLogTransport {
+    send(message: {
+        type: "log";
+        level: WorkerLogLevel;
+        msg: string;
+        meta?: Record<string, unknown>;
+    }): void;
+}
+export declare function sendLog(transport: WorkerLogTransport, level: WorkerLogLevel, msg: string, meta?: Record<string, unknown>): void;
+/**
+ * Generic worker progress event. Each worker's protocol declares an identical
+ * shape with its own `modelKey` type; this is the parameterized version the
+ * shared helpers emit, structurally assignable to each protocol's event.
+ */
+export interface WorkerProgressEvent<K> {
+    modelKey: K;
+    status: "initiate" | "download" | "progress" | "progress_total" | "done" | "ready" | "error";
+    name?: string;
+    file?: string;
+    progress?: number;
+    loaded?: number;
+    total?: number;
+    files?: Record<string, {
+        loaded: number;
+        total: number;
+    }>;
+    task?: string;
+    model?: string;
+}
+/** Minimal transport surface a worker exposes for emitting progress events. */
+export interface WorkerProgressTransport<K> {
+    send(message: {
+        type: "progress";
+        id: string;
+        event: WorkerProgressEvent<K>;
+    }): void;
+}
+export declare function sendProgress<K>(transport: WorkerProgressTransport<K>, id: string, modelKey: K, info: ProgressInfo): void;
+/**
+ * If a model is already warming/warm in `cache`, replay a `ready` progress
+ * event for this request once it resolves and return the cached promise so the
+ * caller can short-circuit; otherwise return `undefined`.
+ */
+export declare function replayCachedReady<K, M>(cache: Map<K, Promise<M>>, modelKey: K, transport: WorkerProgressTransport<K>, requestId: string, task: string, model: string): Promise<M> | undefined;
+/**
+ * Stub `sharp` (the speech/text pipelines are not image codecs, so the native
+ * image dependency is dead weight) and patch the module resolver so a side
+ * runtime's bare requires resolve against its own `node_modules`. Returns the
+ * runtime's `node_modules` directory.
+ */
+export declare function installSharpStubResolver(runtimeDir: string): Promise<string>;
+/**
+ * Lazily resolve (and memoize) the transformers version spec. In the `catalog:`
+ * case {@link resolveTransformersVersionSpec} `require`s the installed
+ * `@huggingface/transformers/package.json`, so it is only ever touched on the
+ * compiled-binary runtime-install path — loading a worker (smoke-test ping,
+ * online path) never triggers the transformers resolve/install dance.
+ */
+export declare function getTransformersVersionSpec(): string;
+/** The subset of the Transformers.js module surface {@link configureTransformers} touches. */
+interface ConfigurableTransformers {
+    env: {
+        cacheDir?: string;
+        allowLocalModels?: boolean;
+        logLevel?: unknown;
+    };
+    LogLevel: {
+        ERROR: unknown;
+    };
+}
+/**
+ * Memoize an async runtime load so it runs at most once per process, clearing
+ * the cache on failure so a later call can retry. Each worker holds one
+ * instance per runtime it loads.
+ */
+export declare class MemoizedRuntime<T> {
+    #private;
+    load(build: () => Promise<T>): Promise<T>;
+}
+/**
+ * Load the `@huggingface/transformers` runtime into `holder` (memoized): from
+ * the ambient install when running from source, or from a version-keyed side
+ * runtime (resolved lazily at `runtimeDir()`) when running as a compiled binary.
+ * The result is cast to the caller's concrete runtime type `T`.
+ */
+export declare function loadTransformersRuntime<T extends ConfigurableTransformers, K>(holder: MemoizedRuntime<T>, transport: WorkerProgressTransport<K>, requestId: string, modelKey: K, runtimeDir: () => string): Promise<T>;
+export {};

package/dist/types/tiny/title-client.d.ts

@@ -1,19 +1,5 @@
-import type { Subprocess } from "bun";
+import { type SpawnedSubprocess, type WorkerHandle } from "../subprocess/worker-client";
 import type { TinyTitleProgressEvent, TinyTitleWorkerInbound, TinyTitleWorkerOutbound } from "./title-protocol";
-/**
- * Abstraction over the tiny-model subprocess. Modelled as a worker interface
- * so existing callers (titles, memory completions, downloads) compose the
- * same way; the runtime implementation is a Bun child process so
- * `onnxruntime-node`'s NAPI finalizer never runs inside the main agent
- * address space — that destructor segfaults Bun on Windows during shutdown
- * (issue #1606).
- */
-interface WorkerHandle {
-    send(message: TinyTitleWorkerInbound): void;
-    onMessage(handler: (message: TinyTitleWorkerOutbound) => void): () => void;
-    onError(handler: (error: Error) => void): () => void;
-    terminate(): Promise<void>;
-}
 export interface TinyTitleDownloadOptions {
     signal?: AbortSignal;
     onProgress?: (event: TinyTitleProgressEvent) => void;
@@ -41,29 +27,24 @@ export declare const TINY_WORKER_ARG = "__omp_worker_tiny_inference";
  * @internal
  */
 export declare function tinyWorkerEnvOverlay(env: Record<string, string | undefined>, deviceSetting: string | undefined, dtypeSetting: string | undefined): Record<string, string>;
-interface SpawnedSubprocess {
-    proc: Subprocess<"ignore", "ignore", "ignore">;
-    inbound: Set<(message: TinyTitleWorkerOutbound) => void>;
-    errors: Set<(error: Error) => void>;
-    /**
-     * Flipped to `true` by {@link wrapSubprocess}'s `terminate()` right
-     * before it SIGKILLs the child so `onExit` can distinguish the
-     * expected hard-kill from a crash/OOM/external signal. Only the
-     * latter is surfaced as a worker error.
-     */
-    intentionalExit: {
-        value: boolean;
-    };
-}
+/**
+ * Env handed to the tiny-model subprocess — and reused verbatim by the STT and
+ * TTS workers, which share the same device/dtype resolution. The
+ * `PI_TINY_DEVICE` / `PI_TINY_DTYPE` env vars win; otherwise the persisted
+ * `providers.tinyModelDevice` / `providers.tinyModelDtype` settings are mapped
+ * onto those vars so the subprocess's env-based resolution picks them up.
+ * Resolved once at spawn (pipelines are cached for the lifetime of the
+ * subprocess).
+ */
+export declare function tinyWorkerEnv(): Record<string, string>;
 /**
  * Spawn the tiny-model worker as a subprocess. Exported for tests and the
- * smoke probe; production callers go through {@link spawnTinyTitleWorker}
- * which wraps the result in a {@link WorkerHandle}.
+ * smoke probe; production callers go through {@link spawnTinyTitleWorker}.
  */
-export declare function createTinyTitleSubprocess(): SpawnedSubprocess;
+export declare function createTinyTitleSubprocess(): SpawnedSubprocess<TinyTitleWorkerOutbound>;
 export declare class TinyTitleClient {
     #private;
-    constructor(spawnWorker?: () => WorkerHandle);
+    constructor(spawnWorker?: () => WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>);
     onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
     generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
     generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;
@@ -81,4 +62,3 @@ export declare function shutdownTinyTitleClient(): Promise<void>;
 export declare function smokeTestTinyTitleWorker({ timeoutMs, }?: {
     timeoutMs?: number;
 }): Promise<void>;
-export {};

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

@@ -2,11 +2,14 @@ import type { ToolSession } from ".";
 export interface EvalBackendsAllowance {
     python: boolean;
     js: boolean;
+    ruby: boolean;
+    julia: boolean;
 }
-/** Read per-backend allowance from settings (defaults true). */
+/** Read per-backend allowance from settings (py/js default on; rb/jl opt-in, default off). */
 export declare function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAllowance;
 /**
- * Materialize the active eval backend allowance: PI_PY / PI_JS env flags
- * override the per-key settings; otherwise settings (defaults true) win.
+ * Materialize the active eval backend allowance: PI_PY / PI_JS / PI_RB / PI_JL
+ * env flags override the per-key settings; otherwise settings win (py/js default
+ * on, rb/jl default off).
  */
 export declare function resolveEvalBackends(session: ToolSession): EvalBackendsAllowance;

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

@@ -2,11 +2,12 @@
  * TUI rendering for the eval tool.
  *
  * Split out from `eval.ts` so the renderer can be imported by `renderers.ts`
- * without dragging the eval *runtime* (JS/Python backends -> agent bridge ->
- * task executor -> sdk -> extension loader -> root barrel) into the renderer
- * module graph. That transitive chain re-enters `renderers.ts` while `eval.ts`
- * is still initializing, which previously crashed module load with a TDZ
- * `Cannot access 'evalToolRenderer' before initialization`.
+ * without dragging the eval *runtime* (JS/Python/Ruby/Julia backends ->
+ * agent bridge -> task executor -> sdk -> extension loader -> root barrel)
+ * into the renderer module graph. That transitive chain re-enters
+ * `renderers.ts` while `eval.ts` is still initializing, which previously
+ * crashed module load with a TDZ `Cannot access 'evalToolRenderer' before
+ * initialization`.
  */
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { EvalStatusEvent, EvalToolDetails } from "../eval/types";

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

@@ -3,25 +3,29 @@ import type { ToolExample } from "@oh-my-pi/pi-ai";
 import type { EvalToolDetails } from "../eval/types";
 import type { ToolSession } from ".";
 export { EVAL_DEFAULT_PREVIEW_LINES, evalToolRenderer } from "./eval-render";
+/** Language tokens the eval tool accepts, in stable display order. */
+export type EvalLanguageToken = "py" | "js" | "rb" | "jl";
 /**
  * Per-cell input. Each cell runs in order; state persists within a language
- * across cells and across tool calls.
+ * across cells and across tool calls. This static schema carries the full
+ * language union for typing; {@link buildEvalSchema} narrows the wire copy per
+ * session so disabled backends are never advertised to the model.
  */
 declare const evalCellSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    language: "js" | "py";
-    code: string;
     title?: string | undefined;
     timeout?: number | undefined;
     reset?: boolean | undefined;
+    language: "jl" | "js" | "py" | "rb";
+    code: string;
 }, {}>;
 export type EvalCellInput = typeof evalCellSchema.infer;
 export declare const evalSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     cells: {
-        language: "js" | "py";
-        code: string;
         title?: string | undefined;
         timeout?: number | undefined;
         reset?: boolean | undefined;
+        language: "jl" | "js" | "py" | "rb";
+        code: string;
     }[];
 }, {}>;
 export type EvalToolParams = typeof evalSchema.infer;
@@ -36,6 +40,8 @@ export type EvalProxyExecutor = (params: EvalToolParams, signal?: AbortSignal) =
 export interface EvalToolDescriptionOptions {
     py?: boolean;
     js?: boolean;
+    rb?: boolean;
+    jl?: boolean;
     /**
      * Whether `agent()` is allowed in this session. Driven by the parent's
      * spawn policy (`getSessionSpawns`). Defaults to `true` for backward
@@ -55,20 +61,12 @@ export declare class EvalTool implements AgentTool<typeof evalSchema> {
     readonly name = "eval";
     readonly approval: "exec";
     readonly formatApprovalDetails: (args: unknown) => string[];
-    readonly summary = "Execute Python or JavaScript code in an in-process eval backend";
+    get summary(): string;
     readonly loadMode = "discoverable";
     readonly label = "Eval";
     get description(): string;
     readonly examples: readonly ToolExample<typeof evalSchema.infer>[];
-    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
-        cells: {
-            language: "js" | "py";
-            code: string;
-            title?: string | undefined;
-            timeout?: number | undefined;
-            reset?: boolean | undefined;
-        }[];
-    }, {}>;
+    get parameters(): typeof evalSchema;
     readonly concurrency = "exclusive";
     readonly strict = true;
     readonly intent: (args: Partial<typeof evalSchema.infer>) => string | undefined;

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

@@ -115,7 +115,7 @@ export interface ToolSession {
     suppressSpawnAdvisory?: boolean;
     /** Optional fetch implementation injected into the URL read pipeline (tests, proxies). Defaults to global fetch. */
     fetch?: FetchImpl;
-    /** Skip Python kernel availability check and warmup */
+    /** Skip subprocess-kernel availability checks and warmup */
     skipPythonPreflight?: boolean;
     /** Pre-loaded context files (AGENTS.md, etc) */
     contextFiles?: ContextFileEntry[];
@@ -152,13 +152,13 @@ export interface ToolSession {
     requireYieldTool?: boolean;
     /** Task recursion depth (0 = top-level, 1 = first child, etc.) */
     taskDepth?: number;
-    /** Get shared eval executor session ID. Subagents inherit this to share JS/Python state. */
+    /** Get shared eval executor session ID. Subagents inherit this to share JS/Python/Ruby/Julia state. */
     getEvalSessionId?: () => string | null;
     /** Get session file */
     getSessionFile: () => string | null;
     /** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */
     getEvalKernelOwnerId?: () => string | null;
-    /** Reject new eval (python or js) work once session disposal has started. */
+    /** Reject new eval work once session disposal has started. */
     assertEvalExecutionAllowed?: () => void;
     /** Track tool-owned eval work so session disposal can await/abort it like direct session eval runs. */
     trackEvalExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;

package/dist/types/tts/tts-client.d.ts

@@ -1,25 +1,10 @@
-import type { Subprocess } from "bun";
+import { type RefCountedWorkerHandle, type SpawnedSubprocess } from "../subprocess/worker-client";
 import type { TtsProgressEvent, TtsWorkerInbound, TtsWorkerOutbound } from "./tts-protocol";
 /** Decoded PCM returned by a local synthesis request. */
 export interface TtsAudio {
     pcm: Float32Array;
     sampleRate: number;
 }
-/**
- * Abstraction over the TTS subprocess. The runtime implementation is a Bun child
- * process so `onnxruntime-node`'s NAPI finalizer never runs inside the main agent
- * address space — that destructor segfaults Bun during shutdown (issue #1606).
- */
-interface WorkerHandle {
-    send(message: TtsWorkerInbound): void;
-    onMessage(handler: (message: TtsWorkerOutbound) => void): () => void;
-    onError(handler: (error: Error) => void): () => void;
-    /** Re-reference the subprocess so a pending request keeps the parent event loop alive. */
-    ref(): void;
-    /** Drop the reference once the worker is idle so it never blocks process exit. */
-    unref(): void;
-    terminate(): Promise<void>;
-}
 export interface TtsSynthesizeOptions {
     voice?: string;
     signal?: AbortSignal;
@@ -55,23 +40,14 @@ export interface TtsStreamHandle {
  * subprocess. Kept in sync with the dispatch in `cli.ts` (Main-owned).
  */
 export declare const TTS_WORKER_ARG = "__omp_worker_tts";
-interface SpawnedSubprocess {
-    proc: Subprocess<"ignore", "ignore", "ignore">;
-    inbound: Set<(message: TtsWorkerOutbound) => void>;
-    errors: Set<(error: Error) => void>;
-    /** Flipped to `true` right before the deliberate SIGKILL so `onExit` can tell it apart from a crash. */
-    intentionalExit: {
-        value: boolean;
-    };
-}
 /**
  * Spawn the TTS worker as a subprocess. Exported for tests and the smoke probe;
  * production callers go through {@link spawnTtsWorker}.
  */
-export declare function createTtsSubprocess(): SpawnedSubprocess;
+export declare function createTtsSubprocess(): SpawnedSubprocess<TtsWorkerOutbound>;
 export declare class TtsClient {
     #private;
-    constructor(spawnWorker?: () => WorkerHandle);
+    constructor(spawnWorker?: () => RefCountedWorkerHandle<TtsWorkerInbound, TtsWorkerOutbound>);
     onProgress(listener: (event: TtsProgressEvent) => void): () => void;
     synthesize(modelKey: string, text: string, options?: TtsSynthesizeOptions): Promise<TtsAudio | null>;
     /**
@@ -90,4 +66,3 @@ export declare function shutdownTtsClient(): Promise<void>;
 export declare function smokeTestTtsWorker({ timeoutMs, }?: {
     timeoutMs?: number;
 }): Promise<void>;
-export {};

package/dist/types/tui/code-cell.d.ts

@@ -18,6 +18,13 @@ export interface CodeCellOptions {
      */
     codeTail?: boolean;
     expanded?: boolean;
+    /**
+     * Prefix the header with the cell's language icon (resolved through the
+     * active symbol preset: nerd-font devicon, unicode emoji, or ascii
+     * shorthand). Opt-in so only the eval kernel renderer labels each cell;
+     * read/write/browser code cells stay icon-free.
+     */
+    showLanguage?: boolean;
     width: number;
     codeStartLine?: number;
     codeLineNumbers?: Array<number | null>;

package/dist/types/utils/file-display-mode.d.ts

@@ -10,7 +10,7 @@ export interface FileDisplayModeSession {
     /** Whether the edit tool is available. Hashlines are suppressed without it. */
     hasEditTool?: boolean;
     settings: {
-        get(key: "readLineNumbers" | "readHashLines" | "edit.mode"): unknown;
+        get(key: "readLineNumbers" | "edit.mode"): unknown;
     };
 }
 /**

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

@@ -1,5 +1,7 @@
 import { type FetchImpl } from "@oh-my-pi/pi-ai";
 import type { AgentStorage } from "../session/agent-storage";
+export declare const PARALLEL_SEARCH_URL = "https://api.parallel.ai/v1beta/search";
+export declare const PARALLEL_BETA_HEADER = "search-extract-2025-10-10";
 export interface ParallelUsageItem {
     name?: string;
     count?: number;
@@ -55,6 +57,10 @@ export declare class ParallelApiError extends Error {
     readonly statusCode?: number;
     constructor(message: string, statusCode?: number);
 }
+export declare function parseParallelErrorResponse(statusCode: number, responseText: string): ParallelApiError;
+export declare function parseParallelSearchPayload(payload: unknown, options?: {
+    parseMetadata?: boolean;
+}): ParallelSearchResult;
 export declare function findParallelApiKey(storage: AgentStorage | null | undefined): string | null;
 export declare function getParallelExtractContent(document: ParallelExtractDocument): string;
 export declare function searchWithParallel(objective: string, queries: string[], options: ParallelSearchOptions, storage: AgentStorage | null | undefined): Promise<ParallelSearchResult>;

package/package.json

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