pi-meta-oauth 0.2.3 → 0.4.0

package/extensions/meta.ts

@@ -13,6 +13,7 @@ export const META_API_BASE_URL = "https://api.meta.ai/v1";
 export const META_MODEL_CATALOG_URL = "https://api.meta.ai/v1/models";
 export const META_AUTH_BASE_URL = "https://auth.meta.com";
 export const META_CLIENT_ID = "1031625952748946";
+export const META_FILES_URL = `${META_API_BASE_URL}/files`;
 
 const DEVICE_AUTHORIZATION_URL = `${META_AUTH_BASE_URL}/oidc/device/authorization/`;
 const DEVICE_TOKEN_URL = `${META_AUTH_BASE_URL}/oidc/device/token/`;
@@ -72,6 +73,10 @@ interface MetaCatalogModel {
 	};
 }
 
+// Media capabilities kept as "text"+"image" for pi-ai type compat (pi-ai 0.83/0.84 only allows those),
+// with "video"/"audio" advertised via cast so future pi-ai that expands the union picks them up.
+// See media.ts for the before_provider_request rewrite that makes @video/@audio work today
+// despite UserMessage.content being string | (TextContent | ImageContent)[] .
 const FALLBACK_MODELS: MetaProviderModel[] = [
 	{
 		id: "muse-spark-1.2",
@@ -86,7 +91,12 @@ const FALLBACK_MODELS: MetaProviderModel[] = [
 			xhigh: "xhigh",
 			max: null,
 		},
-		input: ["text", "image"],
+		input: [
+			"text",
+			"image",
+			"video",
+			"audio",
+		] as unknown as MetaProviderModel["input"],
 		cost: { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 },
 		contextWindow: 1_048_576,
 		maxTokens: 256_000,
@@ -105,7 +115,12 @@ const FALLBACK_MODELS: MetaProviderModel[] = [
 			xhigh: "xhigh",
 			max: null,
 		},
-		input: ["text", "image"],
+		input: [
+			"text",
+			"image",
+			"video",
+			"audio",
+		] as unknown as MetaProviderModel["input"],
 		cost: { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite: 0 },
 		contextWindow: 1_048_576,
 		maxTokens: 256_000,
@@ -124,7 +139,12 @@ const FALLBACK_MODELS: MetaProviderModel[] = [
 			xhigh: "xhigh",
 			max: null,
 		},
-		input: ["text", "image"],
+		input: [
+			"text",
+			"image",
+			"video",
+			"audio",
+		] as unknown as MetaProviderModel["input"],
 		cost: { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 },
 		contextWindow: 1_048_576,
 		maxTokens: 256_000,
@@ -332,6 +352,25 @@ function displayName(id: string): string {
 		.join(" ");
 }
 
+function modalitiesToInput(
+	modalities: string[] | undefined,
+	fallback: MetaProviderModel["input"] | undefined,
+): MetaProviderModel["input"] {
+	if (!modalities)
+		return fallback ?? (["text"] as unknown as MetaProviderModel["input"]);
+	const input: string[] = ["text"];
+	if (modalities.includes("image")) input.push("image");
+	// Advertised via cast until pi-ai expands Model.input union beyond text|image.
+	// The before_provider_request hook in media.ts rewrites these to input_video/input_audio at request time.
+	if (modalities.includes("video")) input.push("video");
+	if (modalities.includes("audio")) input.push("audio");
+	// Some catalogs expose "document"/"pdf" as a modality for PDF handling.
+	if (modalities.includes("document") || modalities.includes("pdf")) {
+		if (!input.includes("image")) input.push("image"); // PDFs count toward image budget
+	}
+	return input as unknown as MetaProviderModel["input"];
+}
+
 export function toProviderModels(
 	catalog: CatalogResponse,
 ): MetaProviderModel[] {
@@ -359,11 +398,7 @@ export function toProviderModels(
 				name: catalogName || fallback?.name || displayName(entry.id),
 				reasoning: metadata?.reasoning ?? fallback?.reasoning ?? true,
 				thinkingLevelMap,
-				input: metadata
-					? metadata.modalities?.input?.includes("image")
-						? ["text", "image"]
-						: ["text"]
-					: (fallback?.input ?? ["text"]),
+				input: modalitiesToInput(metadata?.modalities?.input, fallback?.input),
 				cost: {
 					input: numericCost(metadata?.cost?.input, fallback?.cost.input ?? 0),
 					output: numericCost(

package/extensions/voice/windows-audio.cs

@@ -0,0 +1,281 @@
+// Windows microphone helper for pi-meta-oauth voice.
+// Captures 16 kHz mono PCM via winmm.dll waveIn* and streams base64 JSON lines
+// Protocol mirrors macos-audio.swift:
+//   -> stdout: {"type":"ready","sampleRate":16000,"channels":1,"encoding":"pcm_s16le"}
+//   -> stdout: {"type":"audio","data":"<base64 s16le>"} per captured chunk
+//   -> stdout: {"type":"stopped"}
+//   -> stdout: {"type":"error","message":"..."}
+//   <- stdin: "stop\n" to end capture.
+// Built with: csc.exe /nologo /target:exe /out:pi-meta-oauth-voice-v1.exe windows-audio.cs
+//        or: dotnet build via csc.dll
+// No external dependencies beyond winmm.dll and System.dll.
+
+using System;
+using System.Text;
+using System.Threading;
+using System.Runtime.InteropServices;
+
+class WinVoice
+{
+    // ----- winmm interop -----
+    [StructLayout(LayoutKind.Sequential)]
+    struct WAVEFORMATEX
+    {
+        public ushort wFormatTag;
+        public ushort nChannels;
+        public uint nSamplesPerSec;
+        public uint nAvgBytesPerSec;
+        public ushort nBlockAlign;
+        public ushort wBitsPerSample;
+        public ushort cbSize;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct WAVEHDR
+    {
+        public IntPtr lpData;
+        public uint dwBufferLength;
+        public uint dwBytesRecorded;
+        public IntPtr dwUser;
+        public uint dwFlags;
+        public uint dwLoops;
+        public IntPtr lpNext;
+        public IntPtr reserved;
+    }
+
+    delegate void WaveInProc(IntPtr hwi, uint uMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInGetNumDevs();
+
+    [DllImport("winmm.dll", CharSet = CharSet.Auto)]
+    static extern int waveInGetErrorText(int mmrError, StringBuilder pszText, int cchText);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInOpen(out IntPtr phwi, int uDeviceID, ref WAVEFORMATEX pwfx, WaveInProc dwCallback, IntPtr dwInstance, uint fdwOpen);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInPrepareHeader(IntPtr hwi, IntPtr pwh, int cbwh);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInUnprepareHeader(IntPtr hwi, IntPtr pwh, int cbwh);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInAddBuffer(IntPtr hwi, IntPtr pwh, int cbwh);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInStart(IntPtr hwi);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInStop(IntPtr hwi);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInReset(IntPtr hwi);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInClose(IntPtr hwi);
+
+    const uint CALLBACK_FUNCTION = 0x00030000;
+    const int WAVE_MAPPER = -1;
+    const ushort WAVE_FORMAT_PCM = 1;
+    const uint WIM_DATA = 0x3C0;
+
+    const int BUFFER_BYTES = 3200; // 100 ms @ 16 kHz mono s16le
+    const int BUFFER_COUNT = 3;
+
+    static readonly object emitLock = new object();
+    static WaveInProc callbackDelegate; // keep alive
+    static IntPtr hWaveIn = IntPtr.Zero;
+    static IntPtr[] headerPtrs = new IntPtr[BUFFER_COUNT];
+    static IntPtr[] bufferPtrs = new IntPtr[BUFFER_COUNT];
+    static volatile bool stopping = false;
+    static volatile bool finished = false;
+    static ManualResetEvent done = new ManualResetEvent(false);
+
+    static void Emit(string type, string extraJson = null)
+    {
+        string line;
+        if (extraJson == null) line = "{\"type\":\"" + type + "\"}";
+        else line = "{\"type\":\"" + type + "\"," + extraJson + "}";
+        lock (emitLock)
+        {
+            Console.WriteLine(line);
+            Console.Out.Flush();
+        }
+    }
+
+    static void EmitError(string msg)
+    {
+        string esc = msg.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "\\r").Replace("\n", "\\n");
+        Emit("error", "\"message\":\"" + esc + "\"");
+    }
+
+    static string ErrorText(int code)
+    {
+        var sb = new StringBuilder(256);
+        if (waveInGetErrorText(code, sb, sb.Capacity) == 0 && sb.Length > 0) return sb.ToString();
+        return "winmm error " + code;
+    }
+
+    static void WaveCallback(IntPtr hwi, uint uMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2)
+    {
+        if (uMsg != WIM_DATA) return;
+        if (stopping || finished) return;
+        try
+        {
+            WAVEHDR hdr = (WAVEHDR)Marshal.PtrToStructure(dwParam1, typeof(WAVEHDR));
+            uint recorded = hdr.dwBytesRecorded;
+            if (recorded > 0 && recorded <= hdr.dwBufferLength)
+            {
+                byte[] data = new byte[recorded];
+                Marshal.Copy(hdr.lpData, data, 0, (int)recorded);
+                string b64 = Convert.ToBase64String(data);
+                Emit("audio", "\"data\":\"" + b64 + "\"");
+            }
+            if (!stopping && !finished)
+            {
+                // requeue same header (dwBytesRecorded will be reset by driver)
+                // Need to reset flags? waveInAddBuffer will reuse.
+                int r = waveInAddBuffer(hWaveIn, dwParam1, Marshal.SizeOf(typeof(WAVEHDR)));
+                if (r != 0)
+                {
+                    // If requeue fails, surface error but don't crash callback
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            // Don't emit from callback if already finishing
+            if (!finished) EmitError("wave callback failed: " + ex.Message);
+        }
+    }
+
+    static void Cleanup()
+    {
+        if (hWaveIn != IntPtr.Zero)
+        {
+            try { waveInReset(hWaveIn); } catch { }
+            for (int i = 0; i < BUFFER_COUNT; i++)
+            {
+                if (headerPtrs[i] != IntPtr.Zero)
+                {
+                    try { waveInUnprepareHeader(hWaveIn, headerPtrs[i], Marshal.SizeOf(typeof(WAVEHDR))); } catch { }
+                }
+            }
+            try { waveInClose(hWaveIn); } catch { }
+            hWaveIn = IntPtr.Zero;
+        }
+        for (int i = 0; i < BUFFER_COUNT; i++)
+        {
+            if (bufferPtrs[i] != IntPtr.Zero) { Marshal.FreeHGlobal(bufferPtrs[i]); bufferPtrs[i] = IntPtr.Zero; }
+            if (headerPtrs[i] != IntPtr.Zero) { Marshal.FreeHGlobal(headerPtrs[i]); headerPtrs[i] = IntPtr.Zero; }
+        }
+    }
+
+    static void StopAndExit(int code)
+    {
+        if (finished) return;
+        finished = true;
+        stopping = true;
+        Cleanup();
+        if (code == 0) Emit("stopped");
+        try { Console.Out.Flush(); } catch { }
+        done.Set();
+        Environment.Exit(code);
+    }
+
+    static int Main(string[] args)
+    {
+        // Ctrl+C should produce error rather than silent exit
+        Console.CancelKeyPress += (s, e) => { e.Cancel = true; StopAndExit(0); };
+
+        if (waveInGetNumDevs() == 0)
+        {
+            EmitError("No microphone was found. Check Settings \u2192 Privacy & security \u2192 Microphone and ensure access is allowed.");
+            return 2;
+        }
+
+        var fmt = new WAVEFORMATEX
+        {
+            wFormatTag = WAVE_FORMAT_PCM,
+            nChannels = 1,
+            nSamplesPerSec = 16000,
+            wBitsPerSample = 16,
+            nBlockAlign = 2,
+            nAvgBytesPerSec = 32000,
+            cbSize = 0
+        };
+
+        callbackDelegate = new WaveInProc(WaveCallback);
+
+        int res = waveInOpen(out hWaveIn, WAVE_MAPPER, ref fmt, callbackDelegate, IntPtr.Zero, CALLBACK_FUNCTION);
+        if (res != 0)
+        {
+            string detail = ErrorText(res);
+            if (res == 32) detail += " — Microphone is in use by another app.";
+            // 5 = MMSYSERR_NODRIVER etc hints
+            EmitError("Could not open microphone: " + detail + " Check microphone privacy settings.");
+            return 2;
+        }
+
+        for (int i = 0; i < BUFFER_COUNT; i++)
+        {
+            bufferPtrs[i] = Marshal.AllocHGlobal(BUFFER_BYTES);
+            headerPtrs[i] = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WAVEHDR)));
+            var hdr = new WAVEHDR
+            {
+                lpData = bufferPtrs[i],
+                dwBufferLength = (uint)BUFFER_BYTES,
+                dwBytesRecorded = 0,
+                dwFlags = 0
+            };
+            Marshal.StructureToPtr(hdr, headerPtrs[i], false);
+            res = waveInPrepareHeader(hWaveIn, headerPtrs[i], Marshal.SizeOf(typeof(WAVEHDR)));
+            if (res != 0) { EmitError("Could not prepare audio buffer: " + ErrorText(res)); Cleanup(); return 3; }
+            res = waveInAddBuffer(hWaveIn, headerPtrs[i], Marshal.SizeOf(typeof(WAVEHDR)));
+            if (res != 0) { EmitError("Could not queue audio buffer: " + ErrorText(res)); Cleanup(); return 3; }
+        }
+
+        res = waveInStart(hWaveIn);
+        if (res != 0) { EmitError("Could not start microphone capture: " + ErrorText(res)); Cleanup(); return 4; }
+
+        Emit("ready", "\"sampleRate\":16000,\"channels\":1,\"encoding\":\"pcm_s16le\"");
+
+        // Wait for "stop" on stdin in background (Console.ReadLine blocks)
+        var stdinThread = new Thread(() =>
+        {
+            try
+            {
+                string line;
+                while ((line = Console.ReadLine()) != null)
+                {
+                    if (line.Trim() == "stop")
+                    {
+                        stopping = true;
+                        try { waveInStop(hWaveIn); } catch { }
+                        // Give a brief window for final WIM_DATA to be delivered,
+                        // then reset and exit. 150 ms is enough for trailing 100 ms buffer.
+                        Thread.Sleep(180);
+                        StopAndExit(0);
+                        break;
+                    }
+                }
+                // stdin closed (parent died) -> stop as well
+                if (!finished)
+                {
+                    stopping = true;
+                    try { waveInStop(hWaveIn); } catch { }
+                    Thread.Sleep(120);
+                    StopAndExit(0);
+                }
+            }
+            catch { StopAndExit(0); }
+        });
+        stdinThread.IsBackground = true;
+        stdinThread.Start();
+
+        // Block main thread until done signal
+        done.WaitOne();
+        return 0;
+    }
+}

package/extensions/voice/windows-audio.ps1

@@ -0,0 +1,195 @@
+#Requires -Version 5.1
+# Windows microphone helper for pi-meta-oauth voice (PowerShell fallback).
+# Mirrors windows-audio.cs protocol when a compiled exe is not available.
+# Uses winmm.dll waveIn* via Add-Type compiled C# — no NAudio / ffmpeg required.
+# Protocol:
+#   stdout: {"type":"ready",...}
+#   stdout: {"type":"audio","data":"<base64>"}
+#   stdout: {"type":"stopped"}
+#   stdout: {"type":"error","message":"..."}
+#   stdin:  "stop\n"
+# Run: powershell -NoProfile -ExecutionPolicy Bypass -File windows-audio.ps1
+
+$ErrorActionPreference = "Stop"
+
+$csCode = @"
+using System;
+using System.Text;
+using System.Threading;
+using System.Runtime.InteropServices;
+
+public class PsWinVoice
+{
+    [StructLayout(LayoutKind.Sequential)]
+    struct WAVEFORMATEX
+    {
+        public ushort wFormatTag;
+        public ushort nChannels;
+        public uint nSamplesPerSec;
+        public uint nAvgBytesPerSec;
+        public ushort nBlockAlign;
+        public ushort wBitsPerSample;
+        public ushort cbSize;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct WAVEHDR
+    {
+        public IntPtr lpData;
+        public uint dwBufferLength;
+        public uint dwBytesRecorded;
+        public IntPtr dwUser;
+        public uint dwFlags;
+        public uint dwLoops;
+        public IntPtr lpNext;
+        public IntPtr reserved;
+    }
+
+    delegate void WaveInProc(IntPtr hwi, uint uMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInGetNumDevs();
+    [DllImport("winmm.dll", CharSet = CharSet.Auto)]
+    static extern int waveInGetErrorText(int mmrError, StringBuilder pszText, int cchText);
+    [DllImport("winmm.dll")]
+    static extern int waveInOpen(out IntPtr phwi, int uDeviceID, ref WAVEFORMATEX pwfx, WaveInProc dwCallback, IntPtr dwInstance, uint fdwOpen);
+    [DllImport("winmm.dll")]
+    static extern int waveInPrepareHeader(IntPtr hwi, IntPtr pwh, int cbwh);
+    [DllImport("winmm.dll")]
+    static extern int waveInUnprepareHeader(IntPtr hwi, IntPtr pwh, int cbwh);
+    [DllImport("winmm.dll")]
+    static extern int waveInAddBuffer(IntPtr hwi, IntPtr pwh, int cbwh);
+    [DllImport("winmm.dll")]
+    static extern int waveInStart(IntPtr hwi);
+    [DllImport("winmm.dll")]
+    static extern int waveInStop(IntPtr hwi);
+    [DllImport("winmm.dll")]
+    static extern int waveInReset(IntPtr hwi);
+    [DllImport("winmm.dll")]
+    static extern int waveInClose(IntPtr hwi);
+
+    const uint CALLBACK_FUNCTION = 0x00030000;
+    const int WAVE_MAPPER = -1;
+    const int BUFFER_BYTES = 3200;
+    const int BUFFER_COUNT = 3;
+
+    static object emitLock = new object();
+    static WaveInProc cb;
+    static IntPtr hWaveIn = IntPtr.Zero;
+    static IntPtr[] hdrs = new IntPtr[BUFFER_COUNT];
+    static IntPtr[] bufs = new IntPtr[BUFFER_COUNT];
+    static volatile bool stopping = false;
+    static volatile bool finished = false;
+    static ManualResetEvent done = new ManualResetEvent(false);
+
+    static void Emit(string t, string extra = null)
+    {
+        string line = extra == null ? "{\"type\":\"" + t + "\"}" : "{\"type\":\"" + t + "\"," + extra + "}";
+        lock (emitLock) { Console.WriteLine(line); Console.Out.Flush(); }
+    }
+    static void EmitErr(string m)
+    {
+        string e = m.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "\\r").Replace("\n", "\\n");
+        Emit("error", "\"message\":\"" + e + "\"");
+    }
+    static string ErrTxt(int c)
+    {
+        var sb = new StringBuilder(256);
+        if (waveInGetErrorText(c, sb, sb.Capacity) == 0 && sb.Length > 0) return sb.ToString();
+        return "winmm error " + c;
+    }
+    static void Callback(IntPtr hwi, uint uMsg, IntPtr a, IntPtr pHdr, IntPtr b)
+    {
+        if (uMsg != 0x3C0) return;
+        if (stopping || finished) return;
+        try
+        {
+            WAVEHDR h = (WAVEHDR)Marshal.PtrToStructure(pHdr, typeof(WAVEHDR));
+            uint n = h.dwBytesRecorded;
+            if (n > 0 && n <= h.dwBufferLength)
+            {
+                byte[] d = new byte[n];
+                Marshal.Copy(h.lpData, d, 0, (int)n);
+                Emit("audio", "\"data\":\"" + Convert.ToBase64String(d) + "\"");
+            }
+            if (!stopping && !finished) waveInAddBuffer(hWaveIn, pHdr, Marshal.SizeOf(typeof(WAVEHDR)));
+        }
+        catch (Exception ex) { if (!finished) EmitErr("wave callback failed: " + ex.Message); }
+    }
+    static void Cleanup()
+    {
+        if (hWaveIn != IntPtr.Zero)
+        {
+            try { waveInReset(hWaveIn); } catch {}
+            for (int i = 0; i < BUFFER_COUNT; i++) if (hdrs[i] != IntPtr.Zero) try { waveInUnprepareHeader(hWaveIn, hdrs[i], Marshal.SizeOf(typeof(WAVEHDR))); } catch {}
+            try { waveInClose(hWaveIn); } catch {}
+            hWaveIn = IntPtr.Zero;
+        }
+        for (int i = 0; i < BUFFER_COUNT; i++)
+        {
+            if (bufs[i] != IntPtr.Zero) { Marshal.FreeHGlobal(bufs[i]); bufs[i]=IntPtr.Zero; }
+            if (hdrs[i] != IntPtr.Zero) { Marshal.FreeHGlobal(hdrs[i]); hdrs[i]=IntPtr.Zero; }
+        }
+    }
+    static void StopOk(int code)
+    {
+        if (finished) return;
+        finished = true; stopping = true;
+        Cleanup();
+        if (code == 0) Emit("stopped");
+        try { Console.Out.Flush(); } catch {}
+        done.Set();
+        Environment.Exit(code);
+    }
+
+    public static int Run()
+    {
+        if (waveInGetNumDevs() == 0) { EmitErr("No microphone was found. Check Settings \u2192 Privacy & security \u2192 Microphone."); return 2; }
+        var fmt = new WAVEFORMATEX { wFormatTag = 1, nChannels = 1, nSamplesPerSec = 16000, wBitsPerSample = 16, nBlockAlign = 2, nAvgBytesPerSec = 32000, cbSize = 0 };
+        cb = new WaveInProc(Callback);
+        int r = waveInOpen(out hWaveIn, WAVE_MAPPER, ref fmt, cb, IntPtr.Zero, CALLBACK_FUNCTION);
+        if (r != 0) { EmitErr("Could not open microphone: " + ErrTxt(r) + ". Check microphone privacy settings."); return 2; }
+        for (int i=0;i<BUFFER_COUNT;i++)
+        {
+            bufs[i] = Marshal.AllocHGlobal(BUFFER_BYTES);
+            hdrs[i] = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WAVEHDR)));
+            var h = new WAVEHDR { lpData = bufs[i], dwBufferLength = (uint)BUFFER_BYTES };
+            Marshal.StructureToPtr(h, hdrs[i], false);
+            r = waveInPrepareHeader(hWaveIn, hdrs[i], Marshal.SizeOf(typeof(WAVEHDR)));
+            if (r!=0){ EmitErr("Could not prepare buffer: "+ErrTxt(r)); Cleanup(); return 3; }
+            r = waveInAddBuffer(hWaveIn, hdrs[i], Marshal.SizeOf(typeof(WAVEHDR)));
+            if (r!=0){ EmitErr("Could not queue buffer: "+ErrTxt(r)); Cleanup(); return 3; }
+        }
+        r = waveInStart(hWaveIn);
+        if (r!=0){ EmitErr("Could not start capture: "+ErrTxt(r)); Cleanup(); return 4; }
+        Emit("ready", "\"sampleRate\":16000,\"channels\":1,\"encoding\":\"pcm_s16le\"");
+        var t = new Thread(() => {
+            try {
+                string l;
+                while ((l = Console.ReadLine()) != null) {
+                    if (l.Trim() == "stop") { stopping=true; try{ waveInStop(hWaveIn);}catch{} Thread.Sleep(180); StopOk(0); break; }
+                }
+                if (!finished) { stopping=true; try{ waveInStop(hWaveIn);}catch{} Thread.Sleep(120); StopOk(0); }
+            } catch { StopOk(0); }
+        });
+        t.IsBackground=true; t.Start();
+        done.WaitOne();
+        return 0;
+    }
+}
+"@
+
+try {
+    Add-Type -TypeDefinition $csCode -Language CSharp -ErrorAction Stop | Out-Null
+} catch {
+    # Emit JSON error expected by TypeScript fail path
+    $msg = $_.Exception.Message.Replace('\','\\').Replace('"','\"')
+    Write-Output ('{"type":"error","message":"Failed to initialize Windows audio capture: ' + $msg + '"}')
+    exit 3
+}
+
+# Ensure Console uses UTF8 without BOM for JSON lines
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+
+$code = [PsWinVoice]::Run()
+exit $code