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

package/src/utils/tool-choice.ts

@@ -12,6 +12,19 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
 		return { type: "tool", name: toolName };
 	}
 
+	if (toolName === "computer" && model.supportsComputerUse === true) {
+		if (
+			model.api === "openai-codex-responses" ||
+			model.api === "openai-responses" ||
+			model.api === "azure-openai-responses"
+		) {
+			return { type: "computer" };
+		}
+		return undefined;
+	}
+	// Models without native computer support receive the tool as a regular
+	// function tool, so the generic named-function forcing below applies.
+
 	if (
 		model.api === "openai-codex-responses" ||
 		model.api === "openai-responses" ||
@@ -39,6 +52,7 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
  */
 export function isToolChoiceActive(toolChoice: ToolChoice | undefined, tools: readonly { name: string }[]): boolean {
 	if (!toolChoice || typeof toolChoice === "string") return true;
+	if (toolChoice.type === "computer") return tools.some(tool => tool.name === "computer");
 	const name =
 		toolChoice.type === "tool"
 			? toolChoice.name

package/src/utils/tools-manager.ts

@@ -73,16 +73,6 @@ interface ToolConfig {
 	getAssetName: (version: string, plat: string, architecture: string) => string | null;
 }
 
-// ffmpeg static-binary asset names (eugeneware/ffmpeg-static direct binaries).
-// Maps node arch (arm64|x64) only; everything else is unsupported.
-export function ffmpegAssetName(_version: string, plat: string, architecture: string): string | null {
-	if (architecture !== "arm64" && architecture !== "x64") return null;
-	if (plat === "darwin") return `ffmpeg-darwin-${architecture}`;
-	if (plat === "linux") return `ffmpeg-linux-${architecture}`;
-	if (plat === "win32") return architecture === "x64" ? "ffmpeg-win32-x64" : null;
-	return null;
-}
-
 const TOOLS: Record<string, ToolConfig> = {
 	sd: {
 		name: "sd",
@@ -139,14 +129,6 @@ const TOOLS: Record<string, ToolConfig> = {
 			return null;
 		},
 	},
-	ffmpeg: {
-		name: "ffmpeg",
-		repo: "eugeneware/ffmpeg-static",
-		binaryName: "ffmpeg",
-		tagPrefix: "",
-		isDirectBinary: true,
-		getAssetName: ffmpegAssetName,
-	},
 };
 
 // CLI packages installed via uv/pip
@@ -164,7 +146,7 @@ const PYTHON_TOOLS: Record<string, PythonPackageToolConfig> = {
 	},
 };
 
-export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura" | "ffmpeg";
+export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura";
 
 // Get the path to a tool (system-wide or in our tools dir)
 export function getToolPath(tool: ToolName): string | null {

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>;

package/src/live/audio-worklet.txt

@@ -1,59 +0,0 @@
-class OmpPcmSourceProcessor extends AudioWorkletProcessor {
-	constructor() {
-		super();
-		this.frames = [];
-		this.frameOffset = 0;
-		this.queuedSamples = 0;
-		this.muted = false;
-		this.maxQueuedSamples = Math.floor(sampleRate * 0.75);
-		this.port.onmessage = event => {
-			const message = event.data;
-			if (message.type === "mute") {
-				this.muted = message.muted;
-				this.clear();
-				return;
-			}
-			if (message.type !== "audio" || this.muted || !(message.samples instanceof Float32Array)) return;
-			let samples = message.samples;
-			if (samples.length > this.maxQueuedSamples) samples = samples.slice(samples.length - this.maxQueuedSamples);
-			this.frames.push(samples);
-			this.queuedSamples += samples.length;
-			while (this.queuedSamples > this.maxQueuedSamples && this.frames.length > 1) {
-				const stale = this.frames.shift();
-				this.queuedSamples -= stale.length - this.frameOffset;
-				this.frameOffset = 0;
-			}
-		};
-	}
-
-	clear() {
-		this.frames.length = 0;
-		this.frameOffset = 0;
-		this.queuedSamples = 0;
-	}
-
-	process(_inputs, outputs) {
-		const output = outputs[0];
-		const channel = output && output[0];
-		if (!channel) return true;
-		channel.fill(0);
-		if (this.muted) return true;
-		let outputOffset = 0;
-		while (outputOffset < channel.length && this.frames.length > 0) {
-			const frame = this.frames[0];
-			const available = frame.length - this.frameOffset;
-			const count = Math.min(available, channel.length - outputOffset);
-			channel.set(frame.subarray(this.frameOffset, this.frameOffset + count), outputOffset);
-			outputOffset += count;
-			this.frameOffset += count;
-			this.queuedSamples -= count;
-			if (this.frameOffset === frame.length) {
-				this.frames.shift();
-				this.frameOffset = 0;
-			}
-		}
-		return true;
-	}
-}
-
-registerProcessor("omp-pcm-source", OmpPcmSourceProcessor);

package/src/live/browser-runtime.txt

@@ -1,221 +0,0 @@
-(() => {
-	const INPUT_SAMPLE_RATE = 16_000;
-	const LEVEL_INTERVAL_MS = 50;
-	const OPEN_TIMEOUT_MS = 20_000;
-	let context;
-	let peer;
-	let channel;
-	let sourceNode;
-	let sourceTrack;
-	let remoteSource;
-	let analyser;
-	let levelWaveform;
-	let levelTimer;
-	let disconnectTimer;
-	let workletUrl;
-	let closing = false;
-	let muted = false;
-	let openSettled = false;
-	let openResolve;
-	let openReject;
-	let previousInputSample;
-	let inputPhase = 0;
-	const openPromise = new Promise((resolve, reject) => {
-		openResolve = resolve;
-		openReject = reject;
-	});
-
-	function reportFailure(message) {
-		if (closing) return;
-		if (!openSettled) {
-			openSettled = true;
-			openReject(new Error(message));
-		}
-		Promise.resolve(window.__ompLiveFailure(message)).catch(() => {});
-	}
-
-	function waitForIceGathering() {
-		if (peer.iceGatheringState === "complete") return Promise.resolve();
-		return new Promise((resolve, reject) => {
-			const timeout = setTimeout(() => {
-				peer.removeEventListener("icegatheringstatechange", onChange);
-				reject(new Error("Timed out gathering WebRTC ICE candidates"));
-			}, 10_000);
-			function onChange() {
-				if (peer.iceGatheringState !== "complete") return;
-				clearTimeout(timeout);
-				peer.removeEventListener("icegatheringstatechange", onChange);
-				resolve();
-			}
-			peer.addEventListener("icegatheringstatechange", onChange);
-		});
-	}
-
-	function decodePcm(base64) {
-		const encoded = atob(base64);
-		const bytes = new Uint8Array(encoded.length);
-		for (let index = 0; index < encoded.length; index++) bytes[index] = encoded.charCodeAt(index);
-		const view = new DataView(bytes.buffer);
-		const samples = new Float32Array(bytes.length / 4);
-		for (let index = 0; index < samples.length; index++) samples[index] = view.getFloat32(index * 4, true);
-		return samples;
-	}
-
-	function resample(samples) {
-		if (samples.length === 0) return new Float32Array();
-		const step = INPUT_SAMPLE_RATE / context.sampleRate;
-		const prefix = previousInputSample === undefined ? 0 : 1;
-		const input = new Float32Array(samples.length + prefix);
-		if (prefix === 1) input[0] = previousInputSample;
-		input.set(samples, prefix);
-		if (prefix === 0) inputPhase = 0;
-		const available = input.length - 1;
-		if (available <= 0) {
-			previousInputSample = input[0];
-			return new Float32Array();
-		}
-		const outputLength = Math.max(0, Math.ceil((available - inputPhase) / step));
-		const output = new Float32Array(outputLength);
-		let written = 0;
-		while (inputPhase < available) {
-			const index = Math.floor(inputPhase);
-			const fraction = inputPhase - index;
-			output[written++] = input[index] + (input[index + 1] - input[index]) * fraction;
-			inputPhase += step;
-		}
-		inputPhase -= available;
-		previousInputSample = input[input.length - 1];
-		return written === output.length ? output : output.slice(0, written);
-	}
-
-	function reportLevel() {
-		if (!analyser || !levelWaveform) return;
-		analyser.getFloatTimeDomainData(levelWaveform);
-		let sum = 0;
-		for (const sample of levelWaveform) sum += sample * sample;
-		const level = Math.min(1, Math.max(0, Math.sqrt(sum / levelWaveform.length)));
-		Promise.resolve(window.__ompLiveOutputLevel(level)).catch(() => {});
-	}
-
-	function attachRemoteTrack(event) {
-		if (closing || event.track.kind !== "audio") return;
-		if (remoteSource) remoteSource.disconnect();
-		const stream = new MediaStream([event.track]);
-		remoteSource = context.createMediaStreamSource(stream);
-		analyser = context.createAnalyser();
-		analyser.fftSize = 1024;
-		levelWaveform = new Float32Array(analyser.fftSize);
-		remoteSource.connect(analyser);
-		analyser.connect(context.destination);
-		clearInterval(levelTimer);
-		levelTimer = setInterval(reportLevel, LEVEL_INTERVAL_MS);
-	}
-
-	async function start(workletSource) {
-		if (peer) throw new Error("Live browser runtime already started");
-		context = new AudioContext({ latencyHint: "interactive" });
-		await context.resume();
-		workletUrl = URL.createObjectURL(new Blob([workletSource], { type: "text/javascript" }));
-		await context.audioWorklet.addModule(workletUrl);
-		sourceNode = new AudioWorkletNode(context, "omp-pcm-source", {
-			numberOfInputs: 0,
-			numberOfOutputs: 1,
-			outputChannelCount: [1],
-		});
-		const destination = context.createMediaStreamDestination();
-		sourceNode.connect(destination);
-		sourceTrack = destination.stream.getAudioTracks()[0];
-		sourceTrack.enabled = !muted;
-
-		peer = new RTCPeerConnection();
-		peer.addTrack(sourceTrack, destination.stream);
-		peer.ontrack = attachRemoteTrack;
-		peer.onconnectionstatechange = () => {
-			clearTimeout(disconnectTimer);
-			if (peer.connectionState === "failed" || peer.connectionState === "closed") {
-				reportFailure(`WebRTC peer connection ${peer.connectionState}`);
-			} else if (peer.connectionState === "disconnected") {
-				disconnectTimer = setTimeout(() => {
-					if (peer && peer.connectionState === "disconnected") reportFailure("WebRTC peer connection disconnected");
-				}, 2_000);
-			}
-		};
-		channel = peer.createDataChannel("oai-events");
-		channel.onopen = () => {
-			if (openSettled) return;
-			openSettled = true;
-			openResolve();
-		};
-		channel.onerror = () => reportFailure("Live data channel failed");
-		channel.onclose = () => reportFailure("Live data channel closed unexpectedly");
-		channel.onmessage = event => {
-			if (typeof event.data !== "string") return;
-			Promise.resolve(window.__ompLiveServerEvent(event.data)).catch(() => {});
-		};
-
-		const offer = await peer.createOffer();
-		await peer.setLocalDescription(offer);
-		await waitForIceGathering();
-		if (!peer.localDescription || !peer.localDescription.sdp) throw new Error("Browser produced an empty WebRTC offer");
-		return peer.localDescription.sdp;
-	}
-
-	async function acceptAnswer(sdp) {
-		if (!peer) throw new Error("Live browser runtime has not started");
-		await peer.setRemoteDescription({ type: "answer", sdp });
-	}
-
-	async function waitForOpen() {
-		let timeout;
-		try {
-			await Promise.race([
-				openPromise,
-				new Promise((_, reject) => {
-					timeout = setTimeout(() => reject(new Error("Timed out waiting for the live data channel to open")), OPEN_TIMEOUT_MS);
-				}),
-			]);
-		} finally {
-			clearTimeout(timeout);
-		}
-	}
-
-	function send(payload) {
-		if (!channel || channel.readyState !== "open") throw new Error("Live data channel is not open");
-		channel.send(payload);
-	}
-
-	function pushAudio(base64) {
-		if (!sourceNode || muted) return;
-		const output = resample(decodePcm(base64));
-		if (output.length === 0) return;
-		sourceNode.port.postMessage({ type: "audio", samples: output }, [output.buffer]);
-	}
-
-	function setMuted(nextMuted) {
-		muted = nextMuted;
-		previousInputSample = undefined;
-		inputPhase = 0;
-		if (sourceTrack) sourceTrack.enabled = !muted;
-		if (sourceNode) sourceNode.port.postMessage({ type: "mute", muted });
-	}
-
-	async function close() {
-		if (closing) return;
-		closing = true;
-		clearInterval(levelTimer);
-		clearTimeout(disconnectTimer);
-		if (channel) channel.close();
-		if (peer) peer.close();
-		if (remoteSource) remoteSource.disconnect();
-		if (analyser) analyser.disconnect();
-		if (sourceNode) {
-			sourceNode.port.postMessage({ type: "mute", muted: true });
-			sourceNode.disconnect();
-		}
-		if (sourceTrack) sourceTrack.stop();
-		if (workletUrl) URL.revokeObjectURL(workletUrl);
-		if (context && context.state !== "closed") await context.close();
-	}
-
-	window.ompCodexLive = { start, acceptAnswer, waitForOpen, send, pushAudio, setMuted, close };
-})();