@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.1

package/src/web/search/index.ts

@@ -135,11 +135,9 @@ async function executeSearch(
 	let candidates: SearchProviderCandidate[];
 	if (explicitProvider && explicitProvider !== "auto") {
 		candidates = [{ id: explicitProvider, explicit: true }];
-	} else if (explicitProvider === "auto") {
-		// Explicit `--provider auto` bypasses the configured preferred provider
-		// for this invocation; exclusions still apply.
-		candidates = resolveProviderCandidates("auto");
 	} else {
+		// `--provider auto` and the default both walk the configured chain;
+		// exclusions still apply.
 		candidates = resolveProviderCandidates();
 	}
 
@@ -216,7 +214,6 @@ async function executeSearch(
 			// summary error), masking the cancellation.
 			throwIfAborted(signal);
 			failures.push({ provider: provider ?? providerMeta, error });
-			if (candidate.explicit) break;
 		}
 	}
 
@@ -351,6 +348,6 @@ export function getSearchTools(): CustomTool<any, any>[] {
 	return [webSearchCustomTool];
 }
 
-export { getSearchProvider, setExcludedSearchProviders, setPreferredSearchProvider } from "./provider";
+export { getSearchProvider, setExcludedSearchProviders, setSearchProviderOrder } from "./provider";
 export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
 export { isSearchProviderId, isSearchProviderPreference } from "./types";

package/src/web/search/provider.ts

@@ -189,12 +189,25 @@ export async function getSearchProvider(id: SearchProviderId): Promise<SearchPro
 	return provider;
 }
 
-/** Preferred provider set via settings (default: auto) */
-let preferredProvId: SearchProviderId | "auto" = "auto";
+/** Provider fallback order set via settings (default: built-in order). */
+let orderedProvIds: readonly SearchProviderId[] = SEARCH_PROVIDER_ORDER;
+/** Providers the user explicitly listed in `providers.webSearchOrder`. */
+let explicitProvIds = new Set<SearchProviderId>();
 
-/** Set the preferred web search provider from settings */
-export function setPreferredSearchProvider(provider: SearchProviderId | "auto"): void {
-	preferredProvId = provider;
+/**
+ * Prioritize configured providers while retaining every unlisted provider in
+ * its built-in relative order. Invalid IDs are ignored defensively. Listed
+ * providers are treated as explicit selections: they resolve through
+ * `isExplicitlyAvailable`, so e.g. a hand-listed Perplexity may fall back to
+ * anonymous search exactly like the retired single-preference setting did.
+ */
+export function setSearchProviderOrder(providers: readonly SearchProviderId[]): void {
+	const prioritized = new Set(providers.filter(id => SEARCH_PROVIDER_ORDER.includes(id)));
+	explicitProvIds = prioritized;
+	orderedProvIds =
+		prioritized.size === 0
+			? SEARCH_PROVIDER_ORDER
+			: [...prioritized, ...SEARCH_PROVIDER_ORDER.filter(id => !prioritized.has(id))];
 }
 
 /** Providers excluded from web search resolution via settings. */
@@ -215,19 +228,21 @@ export interface SearchProviderCandidate {
 	explicit: boolean;
 }
 
-/** Return provider candidates in fallback order without loading their modules. */
-export function resolveProviderCandidates(
-	preferredProvider: SearchProviderId | "auto" = preferredProvId,
-): SearchProviderCandidate[] {
+/**
+ * Return provider candidates in fallback order without loading their modules.
+ * `forcedProvider` (a per-request `provider` argument) is terminal-first and
+ * bypasses exclusion; configured-order entries carry `explicit: true`.
+ */
+export function resolveProviderCandidates(forcedProvider?: SearchProviderId): SearchProviderCandidate[] {
 	const candidates: SearchProviderCandidate[] = [];
 
-	if (preferredProvider !== "auto" && !isSearchProviderExcluded(preferredProvider)) {
-		candidates.push({ id: preferredProvider, explicit: true });
+	if (forcedProvider !== undefined && !isSearchProviderExcluded(forcedProvider)) {
+		candidates.push({ id: forcedProvider, explicit: true });
 	}
 
-	for (const id of SEARCH_PROVIDER_ORDER) {
-		if (id === preferredProvider || isSearchProviderExcluded(id)) continue;
-		candidates.push({ id, explicit: false });
+	for (const id of orderedProvIds) {
+		if (id === forcedProvider || isSearchProviderExcluded(id)) continue;
+		candidates.push({ id, explicit: explicitProvIds.has(id) });
 	}
 
 	return candidates;
@@ -241,11 +256,11 @@ export function resolveProviderCandidates(
  */
 export async function resolveProviderChain(
 	authStorage: AuthStorage,
-	preferredProvider: SearchProviderId | "auto" = preferredProvId,
+	forcedProvider?: SearchProviderId,
 ): Promise<SearchProvider[]> {
 	const providers: SearchProvider[] = [];
 
-	for (const candidate of resolveProviderCandidates(preferredProvider)) {
+	for (const candidate of resolveProviderCandidates(forcedProvider)) {
 		const provider = await getSearchProvider(candidate.id);
 		const available = candidate.explicit
 			? await provider.isExplicitlyAvailable(authStorage)

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

@@ -9,7 +9,12 @@ import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const XAI_DEFAULT_BASE_URL = "https://api.x.ai/v1";
-const XAI_WEB_SEARCH_MODEL = "grok-4.3";
+const XAI_WEB_SEARCH_MODEL = "grok-4.5";
+// grok-4.5 defaults reasoning.effort to "high"; xAI documents "low" for
+// latency-sensitive agentic use and simple tool calling
+// (docs.x.ai/developers/model-capabilities/text/reasoning). Web search is
+// exactly that and runs under a 60s hard timeout, so pin the search calls low.
+const XAI_WEB_SEARCH_REASONING_EFFORT = "low";
 const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 30;
 
@@ -60,6 +65,7 @@ function buildRequestBody(params: SearchParams): Record<string, unknown> {
 			{ role: "user", content: params.query },
 		],
 		tools: [{ type: "web_search" }],
+		reasoning: { effort: XAI_WEB_SEARCH_REASONING_EFFORT },
 	};
 
 	if (params.maxOutputTokens !== undefined) {

package/src/web/search/types.ts

@@ -96,6 +96,9 @@ export const SEARCH_PROVIDER_ORDER: readonly SearchProviderId[] = SEARCH_PROVIDE
 	option.value === "auto" ? [] : [option.value],
 );
 
+/** Concrete provider choices (no `auto` sentinel) — for list-valued settings like order/exclude. */
+export const SEARCH_PROVIDER_CHOICES = SEARCH_PROVIDER_OPTIONS.filter(option => option.value !== "auto");
+
 export const SEARCH_PROVIDER_PREFERENCES = ["auto", ...SEARCH_PROVIDER_ORDER] as const;
 
 /** Display labels, derived from {@link SEARCH_PROVIDER_OPTIONS}. */

package/dist/types/stt/recorder.d.ts

@@ -1,30 +0,0 @@
-export interface RecordingHandle {
-    stop(): Promise<void>;
-}
-/**
- * Returns available recording tools in priority order.
- */
-export declare function detectRecordingTools(): string[];
-export interface ResolvedRecorder {
-    tool: "sox" | "ffmpeg" | "arecord" | "powershell";
-    bin: string;
-}
-export declare function detectRecorder(): ResolvedRecorder | null;
-/**
- * Ensure a recorder is available, downloading the static ffmpeg binary when
- * nothing is already present. Returns the resolved recorder.
- */
-export declare function ensureRecorder(onProgress?: (p: {
-    stage: string;
-    percent?: number;
-}) => void, signal?: AbortSignal): Promise<ResolvedRecorder>;
-export declare function startRecording(outputPath: string): Promise<RecordingHandle>;
-/**
- * Verify a recorded audio file is usable.
- * Returns the file size in bytes, or throws.
- */
-export declare function verifyRecordingFile(filePath: string): Promise<number>;
-export interface StreamingRecordingHandle {
-    stop(): Promise<void>;
-}
-export declare function startStreamingRecording(onAudio: (samples: Float32Array) => void): Promise<StreamingRecordingHandle | null>;

package/dist/types/stt/transcriber.d.ts

@@ -1,14 +0,0 @@
-export interface TranscribeOptions {
-    modelName?: string;
-    language?: string;
-    signal?: AbortSignal;
-}
-/**
- * Transcribe a WAV file using the local ONNX Whisper worker.
- *
- * Decodes the WAV to a 16 kHz mono Float32Array in-process (no Python, no
- * ffmpeg) and routes it to the warm speech worker, which keeps the model loaded
- * across calls. Honors `options.signal` (abort) and applies an internal timeout
- * with the same semantics as the previous Python path.
- */
-export declare function transcribe(audioPath: string, options?: TranscribeOptions): Promise<string>;

package/dist/types/stt/wav.d.ts

@@ -1,29 +0,0 @@
-/**
- * Minimal WAV (RIFF/PCM) decoder producing the Float32Array @ 16 kHz mono that
- * transformers.js `automatic-speech-recognition` expects. Ports the decode/
- * mono-mix/resample logic from the retired Python `transcribe.py` (which read
- * via the stdlib `wave` module) so STT no longer shells out to Python.
- *
- * Supported sample formats: PCM uint8 (8-bit), int16 (16-bit), int32 (32-bit),
- * and IEEE float32 (format tag 3). Any number of channels is mixed down to mono.
- */
-/** transformers.js Whisper feature extractor operates at 16 kHz. */
-export declare const TARGET_SAMPLE_RATE = 16000;
-/**
- * Resample via linear interpolation, mirroring the Python `np.interp` over
- * `linspace(0, n-1, targetLen)` against `arange(n)`.
- */
-export declare function resampleLinear(input: Float32Array, fromRate: number, toRate: number): Float32Array;
-/**
- * Decode a WAV byte buffer into a 16 kHz mono Float32Array suitable for the
- * transformers.js Whisper pipeline.
- */
-export declare function decodeWavToMono16k(buffer: ArrayBuffer): Float32Array;
-/**
- * Decode interleaved little-endian signed 16-bit PCM bytes into normalized
- * [-1, 1] mono float samples. The live recorder streams raw s16le frames from
- * sox/ffmpeg/arecord stdout (no RIFF container), so this is the hot-path
- * counterpart to {@link decodeWavToMono16k}. `bytes` MUST be 2-byte aligned;
- * callers buffer any trailing odd byte across chunk boundaries.
- */
-export declare function decodePcmS16LE(bytes: Uint8Array): Float32Array;

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

@@ -1,32 +0,0 @@
-export interface PlayerCommand {
-    cmd: string;
-    args: string[];
-}
-/** Injection seam for {@link playerCommandsFor} — defaults to real PATH/tools lookups. */
-export interface PlayerLookup {
-    which?: (bin: string) => string | null;
-    ffmpeg?: () => string | null;
-}
-/**
- * Build the ordered list of playback commands to try for `filePath` on the
- * given platform. Pure + injectable so the selection logic is testable without
- * spawning anything.
- *
- * - darwin: `afplay` (always present on macOS).
- * - win32: PowerShell `Media.SoundPlayer.PlaySync()` (no extra deps).
- * - linux/other POSIX: `paplay` (PulseAudio) → `aplay` (ALSA) → the bundled
- *   static `ffmpeg` (`-f pulse` then `-f alsa`). Empty result means nothing is
- *   available and the caller should surface an install hint.
- */
-export declare function playerCommandsFor(platform: NodeJS.Platform, filePath: string, lookup?: PlayerLookup): PlayerCommand[];
-export interface PlayAudioOptions {
-    signal?: AbortSignal;
-}
-/**
- * Play `filePath` through the speakers, trying each candidate command in order
- * and returning on the first clean exit. Throws an actionable Error if no
- * player exists or every candidate fails (with the collected stderr).
- */
-export declare function playAudioFile(filePath: string, options?: PlayAudioOptions): Promise<void>;
-/** Best-effort temp-file cleanup used by callers after playback. */
-export declare function removeTempFile(filePath: string): Promise<void>;