@kuralle-syrinx/test 4.4.1 → 4.5.0

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+import { type PipelineBus, type VoicePlugin, type PluginConfig } from "@kuralle-syrinx/core";
+export interface FakeSTTConfig extends PluginConfig {
+    /** Scripted events to emit in order. */
+    scriptedEvents: Array<{
+        kind: "interim";
+        text: string;
+    } | {
+        kind: "final";
+        text: string;
+        confidence: number;
+        ts: number;
+    }>;
+}
+export declare class FakeSTT implements VoicePlugin {
+    private config;
+    private bus;
+    initialize(bus: PipelineBus, config: PluginConfig): Promise<void>;
+    /** Emit scripted events into the bus. Call after audio injection. */
+    emitScripted(contextId: string): Promise<void>;
+    close(): Promise<void>;
+}
+export interface FakeTTSConfig extends PluginConfig {
+    /** Scripted audio batches. Each batch is emitted when tts.text arrives. */
+    scriptedAudioBatches: Array<{
+        frame: {
+            data: Int16Array;
+            sampleRateHz: number;
+            durationMs: number;
+        };
+        final: boolean;
+    }>;
+}
+export declare class FakeTTS implements VoicePlugin {
+    private config;
+    private bus;
+    private batchIndex;
+    initialize(bus: PipelineBus, config: PluginConfig): Promise<void>;
+    private emitNextBatch;
+    close(): Promise<void>;
+}
+export interface FakeVADConfig extends PluginConfig {
+    /**
+     * Array of speech probabilities, one per 20ms audio frame.
+     * Value >= 0.5 → speech, < 0.5 → silence.
+     */
+    scriptedSpeechProbabilities: number[];
+}
+export declare class FakeVAD implements VoicePlugin {
+    private config;
+    private bus;
+    private frameIndex;
+    private speaking;
+    initialize(bus: PipelineBus, config: PluginConfig): Promise<void>;
+    /** Process one frame and emit VAD events based on scripted probability. */
+    processFrame(contextId: string): void;
+    close(): Promise<void>;
+}
+export interface FakeBridgeConfig extends PluginConfig {
+    /** Scripted LLM events in order. */
+    scriptedEvents: Array<{
+        kind: "text";
+        delta: string;
+    } | {
+        kind: "tool_call";
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+    } | {
+        kind: "tool_result";
+        id: string;
+        result: string;
+    } | {
+        kind: "done";
+    }>;
+}
+export declare class FakeBridge implements VoicePlugin {
+    private config;
+    private bus;
+    initialize(bus: PipelineBus, config: PluginConfig): Promise<void>;
+    private emitScripted;
+    close(): Promise<void>;
+}

package/dist/index.js

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: MIT
+//
+// Syrinx Kernel v2 — Test Fakes
+//
+// Fake implementations of VoicePlugin for testing the kernel without
+// real provider connections. Each fake pushes scripted output into the bus.
+import { Route } from "@kuralle-syrinx/core";
+export class FakeSTT {
+    config = null;
+    bus = null;
+    async initialize(bus, config) {
+        this.bus = bus;
+        this.config = config;
+    }
+    /** Emit scripted events into the bus. Call after audio injection. */
+    async emitScripted(contextId) {
+        if (!this.bus || !this.config)
+            return;
+        for (const event of this.config.scriptedEvents) {
+            if (event.kind === "interim") {
+                this.bus.push(Route.Main, {
+                    kind: "stt.interim",
+                    contextId,
+                    timestampMs: Date.now(),
+                    text: event.text,
+                });
+            }
+            else {
+                this.bus.push(Route.Main, {
+                    kind: "stt.result",
+                    contextId,
+                    timestampMs: event.ts,
+                    text: event.text,
+                    confidence: event.confidence,
+                });
+                this.bus.push(Route.Main, {
+                    kind: "eos.turn_complete",
+                    contextId,
+                    timestampMs: event.ts,
+                    text: event.text,
+                    transcripts: [],
+                });
+            }
+        }
+    }
+    async close() {
+        this.bus = null;
+        this.config = null;
+    }
+}
+export class FakeTTS {
+    config = null;
+    bus = null;
+    batchIndex = 0;
+    async initialize(bus, config) {
+        this.bus = bus;
+        this.config = config;
+        // Listen for TTS text
+        bus.on("tts.text", (pkt) => {
+            this.emitNextBatch(pkt.contextId ?? "");
+        });
+    }
+    emitNextBatch(contextId) {
+        if (!this.bus || !this.config)
+            return;
+        const batches = this.config.scriptedAudioBatches;
+        if (this.batchIndex >= batches.length)
+            return;
+        const batch = batches[this.batchIndex];
+        const buf = new Uint8Array(batch.frame.data.buffer);
+        const now = Date.now();
+        this.bus.push(Route.Main, {
+            kind: "tts.audio",
+            contextId,
+            timestampMs: now,
+            audio: buf,
+            sampleRateHz: 16000,
+        });
+        if (batch.final) {
+            this.bus.push(Route.Main, {
+                kind: "tts.end",
+                contextId,
+                timestampMs: now,
+            });
+        }
+        this.batchIndex++;
+    }
+    async close() {
+        this.bus = null;
+        this.config = null;
+    }
+}
+export class FakeVAD {
+    config = null;
+    bus = null;
+    frameIndex = 0;
+    speaking = false;
+    async initialize(bus, config) {
+        this.bus = bus;
+        this.config = config;
+    }
+    /** Process one frame and emit VAD events based on scripted probability. */
+    processFrame(contextId) {
+        if (!this.bus || !this.config)
+            return;
+        const probs = this.config.scriptedSpeechProbabilities;
+        if (this.frameIndex >= probs.length)
+            return;
+        const prob = probs[this.frameIndex];
+        const isSpeech = prob >= 0.5;
+        const now = Date.now();
+        if (isSpeech && !this.speaking) {
+            this.speaking = true;
+            this.bus.push(Route.Main, {
+                kind: "vad.speech_started",
+                contextId,
+                timestampMs: now,
+                confidence: prob,
+            });
+        }
+        if (!isSpeech && this.speaking) {
+            this.speaking = false;
+            this.bus.push(Route.Main, {
+                kind: "vad.speech_ended",
+                contextId,
+                timestampMs: now,
+            });
+        }
+        if (isSpeech) {
+            this.bus.push(Route.Main, {
+                kind: "vad.speech_activity",
+                contextId,
+                timestampMs: now,
+                isAsync: true,
+            });
+        }
+        this.frameIndex++;
+    }
+    async close() {
+        this.bus = null;
+        this.config = null;
+    }
+}
+export class FakeBridge {
+    config = null;
+    bus = null;
+    async initialize(bus, config) {
+        this.bus = bus;
+        this.config = config;
+        // Listen for EOS turn completions
+        bus.on("eos.turn_complete", (pkt) => {
+            const eos = pkt;
+            this.emitScripted(eos.contextId);
+        });
+    }
+    emitScripted(contextId) {
+        if (!this.bus || !this.config)
+            return;
+        for (const event of this.config.scriptedEvents) {
+            switch (event.kind) {
+                case "text":
+                    this.bus.push(Route.Main, {
+                        kind: "llm.delta",
+                        contextId,
+                        timestampMs: Date.now(),
+                        text: event.delta,
+                    });
+                    break;
+                case "tool_call":
+                    this.bus.push(Route.Main, {
+                        kind: "llm.tool_call",
+                        contextId,
+                        timestampMs: Date.now(),
+                        toolId: event.id,
+                        toolName: event.name,
+                        toolArgs: event.args,
+                    });
+                    break;
+                case "tool_result":
+                    this.bus.push(Route.Main, {
+                        kind: "llm.tool_result",
+                        contextId,
+                        timestampMs: Date.now(),
+                        toolId: event.id,
+                        toolName: "",
+                        result: event.result,
+                    });
+                    break;
+                case "done":
+                    this.bus.push(Route.Main, {
+                        kind: "llm.done",
+                        contextId,
+                        timestampMs: Date.now(),
+                        text: "",
+                    });
+                    break;
+            }
+        }
+    }
+    async close() {
+        this.bus = null;
+        this.config = null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuralle-syrinx/test",
-  "version": "4.4.1",
+  "version": "4.5.0",
   "private": false,
   "description": "Scripted fake STT/TTS/LLM plugins for testing Syrinx voice pipelines",
   "keywords": [
@@ -22,13 +22,22 @@
     "url": "https://github.com/kuralle/syrinx/issues"
   },
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "@kuralle-syrinx/core": "4.4.1"
+    "@kuralle-syrinx/core": "4.5.0"
   },
   "devDependencies": {
+    "@types/node": "^22.0.0",
     "typescript": "^5.7.0",
     "vitest": "^3.2.6"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json"
   }
 }