@kuralle-syrinx/google 4.2.0 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuralle-syrinx/google",
-  "version": "4.2.0",
+  "version": "4.4.0",
   "private": false,
   "description": "Google Cloud Speech-to-Text v2 STT adapter for Syrinx",
   "keywords": [
@@ -25,14 +25,15 @@
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "dependencies": {
-    "ws": "^8.18.0",
-    "@kuralle-syrinx/core": "4.2.0",
-    "@kuralle-syrinx/ws": "4.2.0"
+    "ws": "^8.21.0",
+    "@kuralle-syrinx/core": "4.4.0",
+    "@kuralle-syrinx/stt-core": "4.4.0",
+    "@kuralle-syrinx/ws": "4.4.0"
   },
   "devDependencies": {
     "@types/ws": "^8.5.0",
     "typescript": "^5.7.0",
-    "vitest": "^2.1.0"
+    "vitest": "^3.2.6"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/src/index.ts

@@ -3,51 +3,99 @@
 // Syrinx Kernel v2 — Google Cloud Speech-to-Text Plugin
 //
 // Uses Google Cloud Speech-to-Text v2 REST API for streaming recognition.
-// Sends audio chunks, receives interim and final transcripts.
-// Pushes SttInterimPacket, SttResultPacket, and SttErrorPacket into the bus.
+// Wire protocol + lifecycle live in @kuralle-syrinx/stt-core; this file is
+// the Google connect/config/decode surface only.
 //
 // Reference: Rapida transformer/google/stt.go (GCP Speech-to-Text v2 API)
 // Reference: https://cloud.google.com/speech-to-text/v2/docs/streaming-recognize
-//
-// Unlike Deepgram which uses simple API keys, GCP requires:
-//   - API key (for public API) OR
-//   - Service account key (for private/project-scoped API)
-//   - Project ID (required for recognizer path)
 
-import type { PipelineBus } from "@kuralle-syrinx/core";
 import {
   Route,
-  type AudioFormat,
-  type VoicePlugin,
-  type PluginConfig,
-  type SttErrorPacket,
   assertAudioFormat,
-  assertAudioPayload,
-  requireStringConfig,
   optionalStringConfig,
-  categorizeSttError,
-  isRecoverable,
   readProviderRetryConfig,
+  requireStringConfig,
+  type AudioFormat,
+  type PipelineBus,
+  type PluginConfig,
+  type VoicePlugin,
 } from "@kuralle-syrinx/core";
-import { WebSocketConnection, type SocketData, type SocketFactory } from "@kuralle-syrinx/ws";
-
-// =============================================================================
-// Types
-// =============================================================================
-
-interface GCPConfig {
-  recognizer: string;
-  encoding: string;
-  sampleRateHertz: number;
-  languageCodes: string[];
-  model: string;
-  enableAutomaticPunctuation: boolean;
-  interimResults: boolean;
-}
+import {
+  defaultNodeSocketFactory,
+  startStreamingSttSession,
+  type SttEvent,
+  type SttWireProtocol,
+  type StreamingSttSession,
+} from "@kuralle-syrinx/stt-core";
+import type { SocketData, SocketFactory } from "@kuralle-syrinx/ws";
+
+type MetricSink = (name: string, value: string) => void;
+
+class GoogleSttWireProtocol implements SttWireProtocol {
+  constructor(
+    private readonly configMsg: Record<string, unknown>,
+    private readonly confidenceThreshold: number,
+    private readonly onMetric: MetricSink,
+  ) {}
+
+  onOpen(): readonly SocketData[] {
+    return [JSON.stringify(this.configMsg)];
+  }
 
-// =============================================================================
-// Plugin
-// =============================================================================
+  encodeFinalize(_contextId: string): readonly SocketData[] {
+    return [];
+  }
+
+  decode(data: SocketData, _isBinary: boolean): readonly SttEvent[] {
+    if (typeof data !== "string") return [];
+    let msg: { results?: unknown };
+    try {
+      msg = JSON.parse(data) as { results?: unknown };
+    } catch {
+      // Provider keepalives or malformed transient messages are ignored.
+      return [];
+    }
+
+    const results = msg.results;
+    if (!Array.isArray(results) || results.length === 0) return [];
+
+    const events: SttEvent[] = [];
+    for (const result of results) {
+      const r = result as {
+        alternatives?: Array<{ transcript?: unknown; confidence?: number }>;
+        isFinal?: boolean;
+        resultEndOffset?: unknown;
+        resultEndTime?: unknown;
+      };
+      const alt = r.alternatives?.[0];
+      if (!alt?.transcript) continue;
+
+      const text = String(alt.transcript).trim();
+      if (!text) continue;
+      const confidence = alt.confidence ?? 0;
+
+      if (this.confidenceThreshold > 0 && confidence < this.confidenceThreshold) {
+        this.onMetric("stt_low_confidence", String(confidence));
+        continue;
+      }
+
+      if (r.isFinal === true) {
+        const audioSeconds = parseDurationSeconds(r.resultEndOffset ?? r.resultEndTime);
+        events.push({
+          type: "final",
+          contextId: "",
+          text,
+          confidence,
+          speechFinal: true,
+          ...(audioSeconds !== null && audioSeconds > 0 ? { audioSeconds } : {}),
+        });
+      } else {
+        events.push({ type: "interim", contextId: "", text });
+      }
+    }
+    return events;
+  }
+}
 
 export class GoogleSTTPlugin implements VoicePlugin {
   readonly endpointingCapability = {
@@ -59,191 +107,135 @@ export class GoogleSTTPlugin implements VoicePlugin {
 
   constructor(private readonly socketFactory?: SocketFactory) {}
 
-  private bus: PipelineBus | null = null;
-  private conn: WebSocketConnection | null = null;
-  private apiKey: string = "";
-  private projectId: string = "";
-  private languageCode: string = "en-US";
-  private model: string = "latest_long";
-  private endpointUrl: string | undefined;
-  private currentContextId = "";
-  private disposers: Array<() => void> = [];
-  private recognizerPath = "";
-  private sampleRate = 16000;
-  private confidenceThreshold = 0;
-  private emitEosOnFinal = true;
-  private audioFormat: AudioFormat = { encoding: "pcm_s16le", sampleRateHz: 16000, channels: 1 };
+  private session: StreamingSttSession | null = null;
 
   async initialize(bus: PipelineBus, config: PluginConfig): Promise<void> {
-    this.bus = bus;
-    this.apiKey = requireStringConfig(config, "api_key");
-    this.projectId = requireStringConfig(config, "project_id");
-    this.languageCode = optionalStringConfig(config, "language") ?? "en-US";
-    this.model = optionalStringConfig(config, "model") ?? "latest_long";
-    this.endpointUrl = optionalStringConfig(config, "endpoint_url");
-    this.sampleRate = (config["sample_rate"] as number) ?? 16000;
-    this.confidenceThreshold = (config["confidence_threshold"] as number) ?? 0;
-    this.emitEosOnFinal = (config["emit_eos_on_final"] as boolean) ?? true;
-
-    this.recognizerPath = `projects/${this.projectId}/locations/global/recognizers/_`;
-    this.audioFormat = { encoding: "pcm_s16le", sampleRateHz: this.sampleRate, channels: 1 };
-    assertAudioFormat(this.audioFormat);
-    this.conn = new WebSocketConnection({
-      url: () => {
-        return this.endpointUrl ??
-          `wss://speech.googleapis.com/v2/${this.recognizerPath}:streamingRecognize?key=${this.apiKey}`;
-      },
-      socketFactory: this.socketFactory ?? await defaultSocketFactory(),
-      retry: readProviderRetryConfig(config),
-      replayBufferSize: (config["replay_buffer_size"] as number) ?? 64,
-      onReplay: (event, count) => {
-        this.pushMetric(this.currentContextId, `stt.google.reconnect_replay_${event}`, String(count));
-      },
-      onReadyBeforeReplay: () => this.sendConfig(),
-      onMessage: (data) => this.handleMessage(data),
-      onConnectionLost: (err) => {
-        this.emitError(err);
-      },
-      onUnrecoverable: (err) => {
-        this.emitError(err);
-      },
-    });
-    await this.conn.connect();
-
-    this.disposers.push(
-      bus.on("stt.audio", async (pkt: unknown) => {
-        const audioPkt = pkt as { audio: Uint8Array; contextId?: string };
-        this.currentContextId = audioPkt.contextId ?? this.currentContextId;
-        await this.sendAudio(audioPkt.audio);
-      }),
-      bus.on("turn.change", (pkt: unknown) => {
-        this.currentContextId = (pkt as { contextId: string }).contextId;
-      }),
-    );
-  }
-
-  async sendAudio(audio: Uint8Array): Promise<void> {
-    if (audio.byteLength === 0) return;
-    try {
-      assertAudioPayload(this.audioFormat, audio);
-      if (!this.conn) throw new Error("Google STT is not connected");
-      await this.conn.ensureReady();
-      this.conn.send(audio);
-    } catch (err) {
-      this.emitError(err instanceof Error ? err : new Error(String(err)));
-    }
-  }
-
-  async close(): Promise<void> {
-    for (const dispose of this.disposers.splice(0)) dispose();
-    await this.conn?.close();
-    this.conn = null;
-    this.bus = null;
-  }
+    const apiKey = requireStringConfig(config, "api_key");
+    const projectId = requireStringConfig(config, "project_id");
+    const languageCode = optionalStringConfig(config, "language") ?? "en-US";
+    const languageCodes = readStringList(config["language_codes"]) ?? [languageCode];
+    const model = optionalStringConfig(config, "model") ?? "latest_long";
+    const endpointUrl = optionalStringConfig(config, "endpoint_url");
+    const location = optionalStringConfig(config, "location") ?? "global";
+    const recognizerId = optionalStringConfig(config, "recognizer") ?? "_";
+    const sampleRate = (config["sample_rate"] as number) ?? 16000;
+    const encoding = optionalStringConfig(config, "encoding") ?? "LINEAR16";
+    const audioChannelCount =
+      typeof config["channels"] === "number" && Number.isFinite(config["channels"])
+        ? Math.max(1, Math.floor(config["channels"] as number))
+        : 1;
+    const enableAutomaticPunctuation = (config["enable_automatic_punctuation"] as boolean) ?? true;
+    const enableWordConfidence = (config["enable_word_confidence"] as boolean) ?? true;
+    const interimResults = (config["interim_results"] as boolean) ?? true;
+    const recognitionFeatures = readPlainObject(config["recognition_features"]);
+    const streamingFeatures = readPlainObject(config["streaming_features"]);
+    const confidenceThreshold = (config["confidence_threshold"] as number) ?? 0;
+    const emitEosOnFinal = (config["emit_eos_on_final"] as boolean) ?? true;
+
+    const recognizerPath = `projects/${projectId}/locations/${location}/recognizers/${recognizerId}`;
+    const audioFormat: AudioFormat = {
+      encoding: "pcm_s16le",
+      sampleRateHz: sampleRate,
+      channels: 1,
+    };
+    assertAudioFormat(audioFormat);
 
-  private sendConfig(): void {
     const configMsg = {
-      recognizer: this.recognizerPath,
+      recognizer: recognizerPath,
       streamingConfig: {
         config: {
           explicitDecodingConfig: {
-            encoding: "LINEAR16",
-            sampleRateHertz: this.sampleRate,
-            audioChannelCount: 1,
+            encoding,
+            sampleRateHertz: sampleRate,
+            audioChannelCount,
           },
-          languageCodes: [this.languageCode],
-          model: this.model,
+          languageCodes,
+          model,
           features: {
-            enableAutomaticPunctuation: true,
-            enableWordConfidence: true,
+            enableAutomaticPunctuation,
+            enableWordConfidence,
+            ...recognitionFeatures,
           },
         },
         streamingFeatures: {
-          interimResults: true,
+          interimResults,
+          ...streamingFeatures,
         },
       },
     };
-    this.conn?.send(JSON.stringify(configMsg));
+
+    this.session = await startStreamingSttSession(bus, {
+      protocol: new GoogleSttWireProtocol(configMsg, confidenceThreshold, (name, value) => {
+        bus.push(Route.Background, {
+          kind: "metric.conversation",
+          contextId: "",
+          timestampMs: Date.now(),
+          name,
+          value,
+        });
+      }),
+      provider: { name: "google", model, region: "global" },
+      format: audioFormat,
+      language: languageCode,
+      emitEosOnFinal,
+      url: () =>
+        endpointUrl ??
+        `wss://speech.googleapis.com/v2/${recognizerPath}:streamingRecognize?key=${apiKey}`,
+      socketFactory: this.socketFactory ?? (await defaultNodeSocketFactory()),
+      retry: readProviderRetryConfig(config),
+      replayBufferSize: (config["replay_buffer_size"] as number) ?? 64,
+      metricPrefix: "stt.google",
+    });
   }
 
-  private handleMessage(data: SocketData): void {
-    if (typeof data !== "string") return;
-    try {
-      const msg = JSON.parse(data);
-      const results = msg.results;
-      if (!Array.isArray(results) || results.length === 0) return;
-
-      for (const result of results) {
-        const alt = result.alternatives?.[0];
-        if (!alt?.transcript) continue;
-
-        const text = String(alt.transcript).trim();
-        if (!text) continue;
-        const confidence = alt.confidence ?? 0;
-
-        if (this.confidenceThreshold > 0 && confidence < this.confidenceThreshold) {
-          this.pushMetric(this.currentContextId, "stt_low_confidence", String(confidence));
-          continue;
-        }
-
-        if (result.isFinal === true) {
-          this.bus?.push(Route.Main, {
-            kind: "stt.result",
-            contextId: this.currentContextId,
-            timestampMs: Date.now(),
-            text,
-            confidence,
-            language: this.languageCode,
-            provider: { name: "google", model: this.model, region: "global" },
-          });
-          if (this.emitEosOnFinal) {
-            this.bus?.push(Route.Main, {
-              kind: "eos.turn_complete",
-              contextId: this.currentContextId,
-              timestampMs: Date.now(),
-              text,
-              transcripts: [],
-            });
-          }
-        } else {
-          this.bus?.push(Route.Main, {
-            kind: "stt.interim",
-            contextId: this.currentContextId,
-            timestampMs: Date.now(),
-            text,
-          });
-        }
-      }
-    } catch {
-      // Provider keepalives or malformed transient messages are ignored.
-    }
+  async close(): Promise<void> {
+    await this.session?.dispose();
+    this.session = null;
   }
+}
 
-  private emitError(error: Error, category = categorizeSttError(error)): void {
-    const packet: SttErrorPacket = {
-      kind: "stt.error",
-      contextId: this.currentContextId,
-      timestampMs: Date.now(),
-      component: "stt" as const,
-      category,
-      cause: error,
-      isRecoverable: isRecoverable(category),
-    };
-    this.bus?.push(Route.Critical, packet);
+/** Parse Google protobuf Duration JSON (`"1.250s"` or `{seconds,nanos}`) → seconds, or null. */
+function parseDurationSeconds(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.endsWith("s")) {
+      const n = Number(trimmed.slice(0, -1));
+      return Number.isFinite(n) && n >= 0 ? n : null;
+    }
+    const n = Number(trimmed);
+    return Number.isFinite(n) && n >= 0 ? n : null;
   }
+  if (value && typeof value === "object") {
+    const obj = value as { seconds?: unknown; nanos?: unknown };
+    const seconds =
+      typeof obj.seconds === "number"
+        ? obj.seconds
+        : typeof obj.seconds === "string"
+          ? Number(obj.seconds)
+          : 0;
+    const nanos =
+      typeof obj.nanos === "number"
+        ? obj.nanos
+        : typeof obj.nanos === "string"
+          ? Number(obj.nanos)
+          : 0;
+    if (!Number.isFinite(seconds) || !Number.isFinite(nanos)) return null;
+    const total = seconds + nanos / 1e9;
+    return total >= 0 ? total : null;
+  }
+  return null;
+}
 
-  private pushMetric(contextId: string, name: string, value: string): void {
-    this.bus?.push(Route.Background, {
-      kind: "metric.conversation",
-      contextId,
-      timestampMs: Date.now(),
-      name,
-      value,
-    });
+function readPlainObject(value: unknown): Record<string, unknown> | undefined {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
   }
+  return undefined;
 }
 
-async function defaultSocketFactory(): Promise<SocketFactory> {
-  const mod = await import("@kuralle-syrinx/ws/node");
-  return mod.createNodeWsSocket;
+function readStringList(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const list = value.filter((item): item is string => typeof item === "string" && item.length > 0);
+  return list.length > 0 ? list : undefined;
 }

package/src/index.test.ts

@@ -1,273 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { afterEach, describe, expect, it } from "vitest";
-import { WebSocketServer, type WebSocket } from "ws";
-import {
-  PipelineBusImpl,
-  Route,
-  type SttErrorPacket,
-  type SttInterimPacket,
-  type SttResultPacket,
-  type EndOfSpeechPacket,
-} from "@kuralle-syrinx/core";
-import { GoogleSTTPlugin } from "./index.js";
-
-let servers: WebSocketServer[] = [];
-
-afterEach(async () => {
-  await Promise.all(
-    servers.splice(0).map(
-      (server) =>
-        new Promise<void>((resolve) => {
-          for (const client of server.clients) client.terminate();
-          server.close(() => resolve());
-        }),
-    ),
-  );
-});
-
-async function createLocalServer(onConnection: (socket: WebSocket) => void): Promise<string> {
-  const server = await new Promise<WebSocketServer>((resolve) => {
-    let nextServer: WebSocketServer;
-    nextServer = new WebSocketServer({ port: 0 }, () => {
-      resolve(nextServer);
-    });
-  });
-  servers.push(server);
-  server.on("connection", onConnection);
-  const address = server.address();
-  if (!address || typeof address === "string") throw new Error("Expected TCP server address");
-  return `ws://127.0.0.1:${address.port}`;
-}
-
-function startBus(bus: PipelineBusImpl): Promise<void> {
-  const started = bus.start();
-  return started;
-}
-
-describe("GoogleSTTPlugin", () => {
-  it("pushes interim and final packets from Google streaming responses", async () => {
-    const endpointUrl = await createLocalServer((socket) => {
-      socket.once("message", () => {
-        socket.send(JSON.stringify({
-          results: [{
-            isFinal: false,
-            alternatives: [{ transcript: "hello", confidence: 0.7 }],
-          }],
-        }));
-        socket.send(JSON.stringify({
-          results: [{
-            isFinal: true,
-            alternatives: [{ transcript: "hello world", confidence: 0.95 }],
-          }],
-        }));
-      });
-    });
-    const bus = new PipelineBusImpl();
-    const started = startBus(bus);
-    const plugin = new GoogleSTTPlugin();
-    const interims: SttInterimPacket[] = [];
-    const finals: SttResultPacket[] = [];
-    bus.on("stt.interim", (pkt) => {
-      interims.push(pkt as SttInterimPacket);
-    });
-    bus.on("stt.result", (pkt) => {
-      finals.push(pkt as SttResultPacket);
-    });
-
-    await plugin.initialize(bus, {
-      api_key: "test",
-      project_id: "test-project",
-      endpoint_url: endpointUrl,
-    });
-    bus.push(Route.Main, {
-      kind: "stt.audio",
-      contextId: "turn-1",
-      timestampMs: Date.now(),
-      audio: new Uint8Array([1, 2, 3, 4]),
-    });
-    await new Promise((resolve) => setTimeout(resolve, 30));
-
-    expect(interims).toEqual([
-      expect.objectContaining({ kind: "stt.interim", contextId: "turn-1", text: "hello" }),
-    ]);
-    expect(finals).toEqual([
-      expect.objectContaining({
-        kind: "stt.result",
-        contextId: "turn-1",
-        text: "hello world",
-        confidence: 0.95,
-        language: "en-US",
-      }),
-    ]);
-
-    await plugin.close();
-    bus.stop();
-    await started;
-  });
-
-  it("reconnects after a recoverable socket close before sending later audio", async () => {
-    let connections = 0;
-    const receivedFrames: Array<{ connection: number; kind: "config" | "audio"; payload: unknown }> = [];
-    const endpointUrl = await createLocalServer((socket) => {
-      connections++;
-      const connection = connections;
-      if (connections === 1) {
-        socket.close();
-        return;
-      }
-      socket.on("message", (data, isBinary) => {
-        if (isBinary) {
-          receivedFrames.push({ connection, kind: "audio", payload: Buffer.from(data as Buffer) });
-        } else {
-          receivedFrames.push({ connection, kind: "config", payload: JSON.parse(data.toString()) });
-        }
-      });
-    });
-    const bus = new PipelineBusImpl();
-    const started = startBus(bus);
-    const plugin = new GoogleSTTPlugin();
-
-    await plugin.initialize(bus, {
-      api_key: "test",
-      project_id: "test-project",
-      endpoint_url: endpointUrl,
-      retry_base_delay_ms: 1,
-      retry_max_delay_ms: 1,
-    });
-    await new Promise((resolve) => setTimeout(resolve, 30));
-    bus.push(Route.Main, {
-      kind: "stt.audio",
-      contextId: "turn-1",
-      timestampMs: Date.now(),
-      audio: new Uint8Array([9, 8, 7, 6]),
-    });
-    await new Promise((resolve) => setTimeout(resolve, 50));
-
-    expect(connections).toBeGreaterThanOrEqual(2);
-    expect(receivedFrames).toEqual([
-      expect.objectContaining({ connection: 2, kind: "config" }),
-      expect.objectContaining({ connection: 2, kind: "audio", payload: Buffer.from([9, 8, 7, 6]) }),
-    ]);
-
-    await plugin.close();
-    bus.stop();
-    await started;
-  });
-
-  it("uses configured sample_rate in the audio contract and Google decoding config", async () => {
-    const configs: any[] = [];
-    const endpointUrl = await createLocalServer((socket) => {
-      socket.on("message", (data, isBinary) => {
-        if (!isBinary) configs.push(JSON.parse(data.toString()));
-      });
-    });
-    const bus = new PipelineBusImpl();
-    const started = startBus(bus);
-    const plugin = new GoogleSTTPlugin();
-
-    await plugin.initialize(bus, {
-      api_key: "test",
-      project_id: "test-project",
-      endpoint_url: endpointUrl,
-      sample_rate: 8000,
-    });
-    await new Promise((resolve) => setTimeout(resolve, 20));
-
-    expect(configs[0]?.streamingConfig?.config?.explicitDecodingConfig?.sampleRateHertz).toBe(8000);
-
-    await plugin.close();
-    bus.stop();
-    await started;
-  });
-
-  it("suppresses EOS when Smart Turn ownership disables provider finalization", async () => {
-    const endpointUrl = await createLocalServer((socket) => {
-      socket.once("message", () => {
-        socket.send(JSON.stringify({
-          results: [{
-            isFinal: true,
-            alternatives: [{ transcript: "hello world", confidence: 0.95 }],
-          }],
-        }));
-      });
-    });
-    const bus = new PipelineBusImpl();
-    const started = startBus(bus);
-    const plugin = new GoogleSTTPlugin();
-    const finals: SttResultPacket[] = [];
-    const eos: EndOfSpeechPacket[] = [];
-    bus.on("stt.result", (pkt) => {
-      finals.push(pkt as SttResultPacket);
-    });
-    bus.on("eos.turn_complete", (pkt) => {
-      eos.push(pkt as EndOfSpeechPacket);
-    });
-
-    await plugin.initialize(bus, {
-      api_key: "test",
-      project_id: "test-project",
-      endpoint_url: endpointUrl,
-      emit_eos_on_final: false,
-    });
-    bus.push(Route.Main, {
-      kind: "stt.audio",
-      contextId: "turn-no-eos",
-      timestampMs: Date.now(),
-      audio: new Uint8Array([1, 2, 3, 4]),
-    });
-    await new Promise((resolve) => setTimeout(resolve, 30));
-
-    expect(finals).toHaveLength(1);
-    expect(eos).toEqual([]);
-
-    await plugin.close();
-    bus.stop();
-    await started;
-  });
-
-  it("emits stt.error for odd-length PCM16 without throwing into the bus pump", async () => {
-    const receivedAudio: Buffer[] = [];
-    const endpointUrl = await createLocalServer((socket) => {
-      socket.on("message", (data, isBinary) => {
-        if (isBinary) receivedAudio.push(data as Buffer);
-      });
-    });
-    const bus = new PipelineBusImpl();
-    const started = startBus(bus);
-    const plugin = new GoogleSTTPlugin();
-    const errors: SttErrorPacket[] = [];
-    bus.on("stt.error", (pkt) => {
-      errors.push(pkt as SttErrorPacket);
-    });
-
-    await plugin.initialize(bus, {
-      api_key: "test",
-      project_id: "test-project",
-      endpoint_url: endpointUrl,
-    });
-    bus.push(Route.Main, {
-      kind: "stt.audio",
-      contextId: "turn-bad",
-      timestampMs: Date.now(),
-      audio: new Uint8Array([1, 2, 3]),
-    });
-    await new Promise((resolve) => setTimeout(resolve, 30));
-
-    expect(errors).toEqual([
-      expect.objectContaining({
-        kind: "stt.error",
-        contextId: "turn-bad",
-        component: "stt",
-        cause: expect.objectContaining({
-          message: expect.stringMatching(/even number of bytes/i),
-        }),
-      }),
-    ]);
-    expect(receivedAudio).toEqual([]);
-
-    await plugin.close();
-    bus.stop();
-    await started;
-  });
-});

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitReturns": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}