@oh-my-pi/pi-coding-agent 17.1.0 → 17.1.2

package/dist/types/task/structured-subagent.d.ts

@@ -1,3 +1,4 @@
+import type { TaskEffort } from "../thinking.js";
 import type { ToolSession } from "../tools/index.js";
 import { type DiscoveryResult } from "./discovery.js";
 import { type AgentDefinition, type AgentProgress, type SingleResult, type StructuredSubagentOutput } from "./types.js";
@@ -40,6 +41,8 @@ export interface StructuredSubagentRequest {
     /** Presence, rather than truthiness, makes this the highest-priority schema. */
     outputSchema?: unknown;
     schemaMode?: StructuredSubagentSchemaMode;
+    /** Per-spawn thinking effort mapped onto the resolved model's supported range; overrides the agent's default selector. */
+    effort?: TaskEffort;
     identity?: StructuredSubagentIdentity;
     index?: number;
     parentToolCallId?: string;

package/dist/types/task/types.d.ts

@@ -1,7 +1,7 @@
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { type BaseType } from "arktype";
 import type { AgentSessionEvent } from "../session/agent-session.js";
-import type { ConfiguredThinkingLevel } from "../thinking.js";
+import type { ConfiguredThinkingLevel, TaskEffort } from "../thinking.js";
 import type { NestedRepoPatch } from "./worktree.js";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
@@ -83,7 +83,7 @@ export declare const taskItemSchema: import("arktype/internal/variants/object.ts
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
-    model?: string | string[] | undefined;
+    effort?: "hi" | "lo" | "med" | undefined;
     outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
 }, {}>;
@@ -95,8 +95,8 @@ export interface TaskItem {
     agent?: string;
     /** The work; required by the schema. */
     task?: string;
-    /** Explicit model selector or fallback chain for this spawn, including optional reasoning suffixes. */
-    model?: string | string[];
+    /** Per-spawn thinking effort: lowest/middle/highest level the resolved model supports. Overrides the agent's default selector (e.g. `auto`). */
+    effort?: TaskEffort;
     /** Caller-provided output schema; its presence overrides the selected agent's schema. */
     outputSchema?: unknown;
     /** Validation behavior for a caller-provided or inherited output schema. */
@@ -108,7 +108,7 @@ export declare const taskSchema: import("arktype/internal/variants/object.ts").O
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
-    model?: string | string[] | undefined;
+    effort?: "hi" | "lo" | "med" | undefined;
     outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
@@ -117,7 +117,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
-    model?: string | string[] | undefined;
+    effort?: "hi" | "lo" | "med" | undefined;
     outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
@@ -125,7 +125,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
-    model?: string | string[] | undefined;
+    effort?: "hi" | "lo" | "med" | undefined;
     outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
@@ -134,7 +134,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
-        model?: string | string[] | undefined;
+        effort?: "hi" | "lo" | "med" | undefined;
         outputSchema?: string | boolean | object | null | undefined;
         schemaMode?: "permissive" | "strict" | undefined;
         isolated?: boolean | undefined;
@@ -145,7 +145,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
-        model?: string | string[] | undefined;
+        effort?: "hi" | "lo" | "med" | undefined;
         outputSchema?: string | boolean | object | null | undefined;
         schemaMode?: "permissive" | "strict" | undefined;
     }[];
@@ -176,8 +176,8 @@ export interface TaskParams {
     agent?: string;
     /** The work (flat form). */
     task?: string;
-    /** Explicit model selector or fallback chain for the spawn, including optional reasoning suffixes. */
-    model?: string | string[];
+    /** Per-spawn thinking effort (flat form): lowest/middle/highest level the resolved model supports. */
+    effort?: TaskEffort;
     /** Caller-provided output schema; its presence overrides the selected agent's schema. */
     outputSchema?: unknown;
     /** Validation behavior for a caller-provided or inherited output schema. */

package/dist/types/thinking.d.ts

@@ -88,6 +88,19 @@ export declare function parseCliThinkingLevel(value: string | null | undefined):
  * downstream.
  */
 export declare function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort | undefined;
+/** Coarse per-spawn effort selectors accepted by the task tool. */
+export declare const TASK_EFFORTS: readonly ["lo", "med", "hi"];
+/** Coarse task-spawn effort: the lowest, middle, or highest thinking level the target model supports. */
+export type TaskEffort = (typeof TASK_EFFORTS)[number];
+/**
+ * Maps a coarse task effort onto the model's supported thinking range:
+ * `lo` = lowest supported level, `hi` = highest (whatever the model tops out
+ * at — high, xhigh, or max), `med` = the middle (lower of the two middles for
+ * an even-sized range). Without a model, maps over the full canonical range.
+ * Returns `undefined` when the model has no controllable effort surface, so
+ * callers fall back to their default selector (e.g. `auto`).
+ */
+export declare function resolveTaskEffortLevel(model: Model | undefined, effort: TaskEffort): Effort | undefined;
 /**
  * The provisional concrete level shown while `auto` is configured but before a
  * turn has been classified. Prefers the model's `defaultLevel`, otherwise High,

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

@@ -50,6 +50,16 @@ export declare class TinyTitleClient {
     #private;
     constructor(spawnWorker?: () => RefCountedWorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>);
     onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
+    /**
+     * Spawn the tiny-model worker ahead of first use without loading any model.
+     * Called from idle TUI startup so the first {@link generate} reuses a live,
+     * unref'd subprocess instead of paying subprocess-spawn latency on the submit
+     * hot path (issue #6462). No-ops for online / non-local keys and for models
+     * already marked failed. A no-op `ping` round-trips the transport to fault in
+     * the worker's module graph; no pending request is registered, so
+     * {@link #syncWorkerRef} leaves the worker unref'd and idle sessions still exit.
+     */
+    prewarm(modelKey: string): void;
     generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
     generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;
     complete(modelKey: string, prompt: string, options?: {

package/dist/types/tools/builtin-names.d.ts

@@ -1,4 +1,4 @@
-export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "github", "glob", "grep", "lsp", "inspect_image", "browser", "checkpoint", "rewind", "task", "hub", "todo", "web_search", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
+export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "github", "glob", "grep", "lsp", "inspect_image", "browser", "computer", "checkpoint", "rewind", "task", "hub", "todo", "web_search", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 /** Hidden built-ins: constructible and `--tools`-addressable, but never part of the default active set. */
 export declare const HIDDEN_TOOL_NAMES: readonly ["yield", "goal"];

package/dist/types/tools/computer/protocol.d.ts

@@ -0,0 +1,43 @@
+import type { DesktopAction, DesktopCapabilities, DesktopCapture, DesktopSessionOptions } from "@oh-my-pi/pi-natives";
+export declare const COMPUTER_WORKER_ARG = "__omp_worker_computer";
+export type ComputerWorkerInbound = {
+    type: "ping";
+    id: string;
+} | {
+    type: "init";
+    options: DesktopSessionOptions;
+} | {
+    type: "execute";
+    id: string;
+    actions: DesktopAction[];
+} | {
+    type: "close";
+};
+export type ComputerWorkerOutbound = {
+    type: "pong";
+    id: string;
+} | {
+    type: "ready";
+    capabilities: DesktopCapabilities;
+} | {
+    type: "result";
+    id: string;
+    capture: DesktopCapture;
+    capabilities: DesktopCapabilities;
+} | {
+    type: "error";
+    id?: string;
+    error: ComputerWorkerError;
+} | {
+    type: "closed";
+};
+export interface ComputerWorkerError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+export interface ComputerWorkerTransport {
+    send(message: ComputerWorkerOutbound, transfer?: Bun.Transferable[]): void;
+    onMessage(handler: (message: ComputerWorkerInbound) => void): () => void;
+    close(): void;
+}

package/dist/types/tools/computer/supervisor.d.ts

@@ -0,0 +1,32 @@
+import type { DesktopAction, DesktopCapabilities, DesktopCapture, DesktopSessionOptions } from "@oh-my-pi/pi-natives";
+import { type ComputerWorkerInbound, type ComputerWorkerOutbound } from "./protocol.js";
+export interface ComputerController {
+    readonly capabilities: DesktopCapabilities | undefined;
+    execute(actions: DesktopAction[], signal?: AbortSignal): Promise<DesktopCapture>;
+    close(): Promise<void>;
+}
+export interface ComputerWorkerHandle {
+    send(message: ComputerWorkerInbound): void;
+    onMessage(handler: (message: ComputerWorkerOutbound) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    terminate(): Promise<void>;
+}
+export interface ComputerSupervisorTimeouts {
+    startMs: number;
+    closeMs: number;
+}
+export type ComputerWorkerFactory = () => ComputerWorkerHandle;
+export declare function spawnComputerWorker(): ComputerWorkerHandle;
+export declare class ComputerSupervisor implements ComputerController {
+    #private;
+    private readonly options;
+    private readonly createWorker;
+    private readonly timeouts;
+    constructor(options: DesktopSessionOptions, createWorker?: ComputerWorkerFactory, timeouts?: ComputerSupervisorTimeouts);
+    get capabilities(): DesktopCapabilities | undefined;
+    execute(actions: DesktopAction[], signal?: AbortSignal): Promise<DesktopCapture>;
+    close(): Promise<void>;
+}
+export declare function registerComputerController(ownerId: string | undefined, controller: ComputerController): () => void;
+export declare function releaseComputerSessionsForOwner(ownerId: string | undefined): Promise<void>;
+export declare function smokeTestComputerWorker(timeoutMs?: number): Promise<void>;

package/dist/types/tools/computer/worker-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tools/computer/worker.d.ts

@@ -0,0 +1,15 @@
+import { type DesktopAction, type DesktopCapture, DesktopSession, type DesktopSessionOptions } from "@oh-my-pi/pi-natives";
+import type { ComputerWorkerTransport } from "./protocol.js";
+export interface NativeDesktopSession {
+    readonly capabilities: DesktopSession["capabilities"];
+    capture(): Promise<DesktopCapture>;
+    execute(actions: DesktopAction[]): Promise<DesktopCapture>;
+    close(): Promise<void>;
+}
+export type NativeDesktopSessionFactory = (options: DesktopSessionOptions) => NativeDesktopSession;
+export declare class ComputerWorkerCore {
+    #private;
+    private readonly transport;
+    private readonly createSession;
+    constructor(transport: ComputerWorkerTransport, createSession?: NativeDesktopSessionFactory);
+}

package/dist/types/tools/computer-renderer.d.ts

@@ -0,0 +1,22 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
+import type { Theme } from "../modes/theme/theme.js";
+interface ComputerRenderArgs {
+    actions?: Array<{
+        type?: unknown;
+    }>;
+}
+interface ComputerRenderResult {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: unknown;
+    isError?: boolean;
+}
+export declare const computerToolRenderer: {
+    mergeCallAndResult: boolean;
+    renderCall(args: ComputerRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: ComputerRenderResult, options: RenderResultOptions, theme: Theme, args?: ComputerRenderArgs): Component;
+};
+export {};

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

@@ -0,0 +1,71 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
+import type { ComputerAction } from "@oh-my-pi/pi-ai";
+import type { DesktopCapabilities, DesktopCapture, DesktopDisplay, DesktopSessionOptions } from "@oh-my-pi/pi-natives";
+import { type ComputerController } from "./computer/supervisor.js";
+import type { ToolSession } from "./index.js";
+declare const computerSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    actions?: {
+        type: "click" | "double_click" | "drag" | "keypress" | "move" | "screenshot" | "scroll" | "type" | "wait";
+        x?: number | undefined;
+        y?: number | undefined;
+        button?: "back" | "forward" | "left" | "right" | "wheel" | undefined;
+        path?: {
+            x: number;
+            y: number;
+        }[] | undefined;
+        keys?: string[] | null | undefined;
+        scroll_x?: number | undefined;
+        scroll_y?: number | undefined;
+        text?: string | undefined;
+    }[] | undefined;
+}, {}>;
+export type ComputerParams = typeof computerSchema.infer;
+export interface ComputerToolDetails {
+    width: number;
+    height: number;
+    backend: DesktopCapture["backend"];
+    displayServer?: string;
+    capturePermission: string;
+    inputPermission: string;
+    displays: DesktopDisplay[];
+    capabilities?: DesktopCapabilities;
+    actions: ComputerAction["type"][];
+}
+export type ComputerControllerFactory = (options: DesktopSessionOptions) => ComputerController;
+export declare function computerApproval(args: unknown): ToolApprovalDecision;
+export declare class ComputerTool implements AgentTool<typeof computerSchema, ComputerToolDetails> {
+    #private;
+    readonly session: ToolSession;
+    readonly name = "computer";
+    readonly native: {
+        readonly type: "computer";
+    };
+    readonly label = "Computer";
+    readonly loadMode: "essential";
+    readonly concurrency: "exclusive";
+    readonly summary = "Capture and control the host desktop through native OS APIs";
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        actions?: {
+            type: "click" | "double_click" | "drag" | "keypress" | "move" | "screenshot" | "scroll" | "type" | "wait";
+            x?: number | undefined;
+            y?: number | undefined;
+            button?: "back" | "forward" | "left" | "right" | "wheel" | undefined;
+            path?: {
+                x: number;
+                y: number;
+            }[] | undefined;
+            keys?: string[] | null | undefined;
+            scroll_x?: number | undefined;
+            scroll_y?: number | undefined;
+            text?: string | undefined;
+        }[] | undefined;
+    }, {}>;
+    readonly strict = false;
+    readonly approval: typeof computerApproval;
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    constructor(session: ToolSession, createController?: ComputerControllerFactory);
+    get description(): string;
+    execute(_toolCallId: string, params: ComputerParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ComputerToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<ComputerToolDetails>>;
+    close(): Promise<void>;
+}
+export {};

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

@@ -12,6 +12,8 @@ declare module "@oh-my-pi/pi-agent-core" {
          *  wrapper must not re-prompt for the same action (explicit per-tool
          *  policies and overrides still apply). */
         xdevApproved?: boolean;
+        /** Set only after an interactive prompt approves provider computer safety checks. */
+        providerSafetyApproved?: boolean;
     }
 }
 export declare class ToolContextStore {

package/dist/types/tools/default-renderer.d.ts

@@ -0,0 +1,21 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
+import type { Theme } from "../modes/theme/theme.js";
+/** Inputs rendered by the fallback card used when a tool has no bespoke renderer. */
+export interface DefaultToolRenderInput {
+    /** Human-readable tool label. */
+    label: string;
+    /** Tool arguments, shown inline when collapsed and as a tree when expanded. */
+    args: unknown;
+    /** Settled or streaming result; omitted while only the call is available. */
+    result?: {
+        output: string;
+        isError?: boolean;
+    };
+    /** Current expansion and lifecycle state. */
+    options: RenderResultOptions;
+}
+/** Format one generic tool call/result card at the available content width. */
+export declare function formatDefaultToolExecution(input: DefaultToolRenderInput, contentWidth: number, uiTheme: Theme): string;
+/** Render the generic fallback as the state-tinted card used by direct custom tools. */
+export declare function renderDefaultToolExecution(input: DefaultToolRenderInput, uiTheme: Theme): Component;

package/dist/types/tools/eval-format/index.d.ts

@@ -0,0 +1,7 @@
+import type { EvalLanguage } from "../../eval/types.js";
+export * from "./javascript.js";
+export * from "./julia.js";
+export * from "./python.js";
+export * from "./ruby.js";
+/** Formats an arbitrary eval-code prefix for display without changing the executed source. */
+export declare function formatEvalCodeForDisplay(source: string, language: EvalLanguage): string;

package/dist/types/tools/eval-format/javascript.d.ts

@@ -0,0 +1,2 @@
+/** Formats JavaScript/TypeScript-like eval source for safe, stable display without requiring valid syntax. */
+export declare function formatJavaScriptForDisplay(source: string): string;

package/dist/types/tools/eval-format/julia.d.ts

@@ -0,0 +1,2 @@
+/** Formats an arbitrary Julia source prefix for stable, readable display. */
+export declare function formatJuliaForDisplay(source: string): string;

package/dist/types/tools/eval-format/python.d.ts

@@ -0,0 +1,2 @@
+/** Formats an arbitrary Python source prefix for stable, readable display. */
+export declare function formatPythonForDisplay(source: string): string;

package/dist/types/tools/eval-format/ruby.d.ts

@@ -0,0 +1,2 @@
+/** Formats an arbitrary Ruby source prefix for display without requiring valid syntax. */
+export declare function formatRubyForDisplay(source: string): string;

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

@@ -42,6 +42,8 @@ export * from "./ast-grep.js";
 export * from "./bash.js";
 export * from "./browser.js";
 export * from "./checkpoint.js";
+export * from "./computer.js";
+export * from "./computer/supervisor.js";
 export * from "./debug.js";
 export * from "./essential-tools.js";
 export * from "./eval.js";

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

@@ -27,6 +27,13 @@ export declare const PROPOSE_DEVICE_NAME = "propose";
 export declare const RESOLVE_DEVICE_PATH = "xd://resolve";
 export declare const REJECT_DEVICE_PATH = "xd://reject";
 export declare const PROPOSE_DEVICE_PATH = "xd://propose";
+/**
+ * Model-visible banner prepended to a staged preview's tool result text. The
+ * TUI badge (`⟨proposed⟩`) never reaches the model, and preview diffs are
+ * byte-identical to applied-edit output — without this line the model reads
+ * the result as an already-applied change.
+ */
+export declare const PREVIEW_PENDING_NOTICE = "Staged as a proposal \u2014 files NOT modified yet. To apply: write a one-sentence reason to xd://resolve. To discard: write to xd://reject.";
 export type ResolutionDeviceName = typeof RESOLVE_DEVICE_NAME | typeof REJECT_DEVICE_NAME | typeof PROPOSE_DEVICE_NAME;
 /** Whether an xd:// device name is one of the plain-text resolution devices. */
 export declare function isResolutionDeviceName(name: string): name is ResolutionDeviceName;

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

@@ -44,6 +44,8 @@ declare const todoSchema: import("arktype/internal/variants/object.ts").ObjectTy
 }, {}>;
 type TodoParams = TodoSchema;
 type TodoSchema = typeof todoSchema.infer;
+/** A single todo op entry (the params object itself). */
+type TodoOpEntryValue = TodoParams;
 /** Return the active todo task, preferring an in-progress item over the first pending item. */
 export declare function nextActionableTask(phases: readonly TodoPhase[]): TodoItem | undefined;
 export declare const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
@@ -92,7 +94,7 @@ export declare function selectCollapsedTodos<T extends {
     status: TodoStatus;
 }>(tasks: T[], isMatched: (task: T) => boolean, cap: number): CollapsedTodoSelection<T>;
 /** Apply an array of `todo`-style ops to existing phases. Used by /todo slash command. */
-export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoParams[]): {
+export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoOpEntryValue[]): {
     phases: TodoPhase[];
     errors: string[];
 };
@@ -124,6 +126,7 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
     }, {}>;
     readonly concurrency = "exclusive";
     readonly strict = true;
+    readonly lenientArgValidation = true;
     readonly examples: readonly ToolExample<typeof todoSchema.infer>[];
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);

package/dist/types/tts/streaming-player.d.ts

@@ -1,54 +1,21 @@
-import { type PlayerCommand } from "./player.js";
-/** Output gain applied while ducked (the user is speaking over the assistant). */
+/** Output gain applied while the user speaks over assistant audio. */
 export declare const DUCK_GAIN = 0.25;
-/** Injection seam for {@link streamingPlayerCommandsFor} — defaults to real PATH/tools lookups. */
-export interface StreamingPlayerLookup {
-    which?: (bin: string) => string | null;
-    ffmpeg?: () => string | null;
-}
-/**
- * Ordered candidate commands for a persistent raw-PCM player on `platform`: each
- * reads 32-bit-float little-endian mono PCM at `sampleRate` from stdin (`pipe:0`)
- * and plays it to the default output device. An empty list means no streaming
- * backend is available and the caller should fall back to per-file playback.
- *
- * - darwin: `ffmpeg` (AudioToolbox output device) → sox's `play` (coreaudio).
- * - linux/other POSIX: `ffmpeg` (`-f pulse` then `-f alsa`) → `paplay`/`aplay`
- *   raw fallbacks.
- * - win32: none (PowerShell `SoundPlayer` is file-only).
- */
-export declare function streamingPlayerCommandsFor(platform: NodeJS.Platform, sampleRate: number, lookup?: StreamingPlayerLookup): PlayerCommand[];
-/**
- * Test seams for {@link StreamingAudioPlayer}: override backend discovery and
- * the per-file fallback so playback logic can be exercised without a real audio
- * device. Both default to the platform lookup and {@link playAudioFile}.
- */
-export interface StreamingPlayerOptions {
-    /** Ordered backend commands for a sample rate; defaults to {@link streamingPlayerCommandsFor}. */
-    commandsFor?: (sampleRate: number) => PlayerCommand[];
-    /** Per-file fallback playback; defaults to {@link playAudioFile}. */
-    playAudio?: (wavPath: string, signal: AbortSignal) => Promise<void>;
-    /** Max seconds of streamed PCM retained for the nonzero-exit replay; defaults to {@link REPLAY_RETENTION_SECONDS}. */
-    replayRetentionSeconds?: number;
-}
 /**
- * Single-session gapless player. Lifecycle: {@link start} once, {@link write}
- * chunks in order, then {@link end} to drain or {@link stop} to abort. Not
- * reusable after stop/end — create a new instance per utterance.
+ * One native gapless playback session. Call {@link start}, enqueue mono `f32`
+ * chunks with {@link write}, then {@link end} to drain or {@link stop} to abort.
  */
 export declare class StreamingAudioPlayer {
     #private;
-    constructor(options?: StreamingPlayerOptions);
-    /** Pick a backend and begin draining. Idempotent; the first call's rate wins. */
-    start(sampleRate: number): void;
-    /** Queue a mono float32 PCM chunk for playback in arrival order. */
+    /** Opens the default speaker at the stream's logical sample rate. */
+    start(sampleRate?: number): void;
+    /** Queues one mono `f32` PCM chunk without copying it in TypeScript. */
     write(pcm: Float32Array): void;
-    /** Scale subsequent output (1 = normal, <1 = ducked). Applies within {@link LEAD_SECONDS}. */
+    /** Applies gain at render time, including to samples already queued natively. */
     setGain(gain: number): void;
-    /** Close the input; resolves once all queued audio has finished playing. */
+    /** Closes input and resolves after every queued sample reaches the speaker. */
     end(): Promise<void>;
-    /** Stop immediately: kill the player, drop everything still queued. */
+    /** Stops immediately and discards queued audio. Safe to call repeatedly. */
     stop(): void;
 }
-/** Factory the vocalizer calls; a function so tests can stub it without spawning a player. */
+/** Creates the single-use player used by the speech vocalizer. */
 export declare function createStreamingPlayer(): StreamingAudioPlayer;

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

@@ -1,5 +1,4 @@
-export declare function ffmpegAssetName(_version: string, plat: string, architecture: string): string | null;
-export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura" | "ffmpeg";
+export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura";
 export declare function getToolPath(tool: ToolName): string | null;
 /** Download a tool asset without handing the streaming Response to Bun.write. */
 export declare function downloadFile(url: string, dest: string, signal?: AbortSignal): Promise<void>;

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

@@ -1,5 +1,6 @@
 import type { AuthStorage, FetchImpl } from "@oh-my-pi/pi-ai";
 import type { ModelRegistry } from "../../../config/model-registry.js";
+import type { StructuredQuery } from "../query.js";
 import type { SearchProviderId, SearchResponse } from "../types.js";
 /**
  * Shared web search parameters passed to providers.
@@ -13,6 +14,21 @@ import type { SearchProviderId, SearchResponse } from "../types.js";
  */
 export interface SearchParams {
     query: string;
+    /**
+     * Structured view of `query`, parsed once by the search pipeline:
+     * Google-style directives (`site:`, `before:`/`after:`, `inurl:`,
+     * `intitle:`, `filetype:`, quoted phrases, `OR` groups, `-exclusions`)
+     * extracted into fields.
+     *
+     * Providers SHOULD map constraints onto native API parameters
+     * (domain/date filters) or engine query syntax (`formatQuery`) where the
+     * upstream supports them, and lean lenient otherwise: the pipeline
+     * post-filters every response with `applyQueryConstraints`, which
+     * relaxes any constraint that would eliminate all results — so a
+     * best-effort search always beats an empty one. When absent (direct
+     * provider calls), parse with `parseSearchQuery(params.query)`.
+     */
+    parsedQuery?: StructuredQuery;
     limit?: number;
     /**
      * Temporal filter narrowing results to the specified time window.

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

@@ -6,12 +6,14 @@
  */
 import { type AuthStorage, type FetchImpl } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types.js";
+import type { StructuredQuery } from "../query.js";
 import type { SearchParams } from "./base.js";
 import { SearchProvider } from "./base.js";
 export interface BraveSearchParams {
     query: string;
     num_results?: number;
     recency?: "day" | "week" | "month" | "year";
+    parsedQuery?: StructuredQuery;
     signal?: AbortSignal;
     fetch?: FetchImpl;
 }

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

@@ -12,6 +12,8 @@ export interface FirecrawlSearchParams {
     query: string;
     num_results?: number;
     recency?: SearchParams["recency"];
+    /** Explicit `tbs` (custom date range); takes precedence over `recency`. */
+    tbs?: string;
     signal?: AbortSignal;
     fetch?: FetchImpl;
 }

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

@@ -10,6 +10,7 @@
  */
 import { type AuthStorage, type FetchImpl, type OAuthAccess } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types.js";
+import { type StructuredQuery } from "../query.js";
 import type { SearchParams } from "./base.js";
 import { SearchProvider } from "./base.js";
 declare const GEMINI_PROVIDERS: readonly ["google-gemini-cli", "google-antigravity"];
@@ -21,6 +22,8 @@ interface GeminiToolParams {
 }
 export interface GeminiSearchParams extends GeminiToolParams {
     query: string;
+    /** Pre-parsed structured query; falls back to parsing `query` when omitted. */
+    parsedQuery?: StructuredQuery;
     system_prompt?: string;
     num_results?: number;
     /** Maximum output tokens. */

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

@@ -14,6 +14,8 @@ type SearchParamsWithFetch = SearchParams & {
 export interface JinaSearchParams {
     query: string;
     num_results?: number;
+    /** Single bare host for Jina's `X-Site` in-site search header. */
+    site?: string;
     signal?: AbortSignal;
     fetch?: FetchImpl;
 }

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

@@ -5,6 +5,7 @@
  */
 import type { AuthStorage, FetchImpl } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types.js";
+import type { StructuredQuery } from "../query.js";
 import type { SearchParams } from "./base.js";
 import { SearchProvider } from "./base.js";
 type SearchParamsWithFetch = SearchParams & {
@@ -15,6 +16,7 @@ export declare function searchKagi(params: {
     query: string;
     num_results?: number;
     recency?: SearchParams["recency"];
+    parsedQuery?: StructuredQuery;
     signal?: AbortSignal;
     authStorage: AuthStorage;
     sessionId?: string;