@kuralle-syrinx/pipecat-smart-turn 4.2.0 → 4.4.0

package/src/interaction-policy.test.ts

@@ -1,136 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-
-import { SmartTurnInteractionPolicy } from "./interaction-policy.js";
-import type { SmartTurnPredictor } from "./predictor.js";
-
-class PredictableSmartTurn implements SmartTurnPredictor {
-  initialized = false;
-  closed = false;
-
-  constructor(private readonly probabilities: number[]) {}
-
-  async initialize(): Promise<void> {
-    this.initialized = true;
-  }
-
-  async predict(): Promise<number> {
-    return this.probabilities.shift() ?? 0;
-  }
-
-  async close(): Promise<void> {
-    this.closed = true;
-  }
-}
-
-function speechStarted(contextId = "turn-1") {
-  return {
-    kind: "vad_speech_started" as const,
-    contextId,
-    timestampMs: 1000,
-    confidence: 0.95,
-  };
-}
-
-function speechEnded(contextId = "turn-1") {
-  return {
-    kind: "vad_speech_ended" as const,
-    contextId,
-    timestampMs: 1500,
-    hasActiveTts: false,
-  };
-}
-
-function audioFrame(contextId = "turn-1") {
-  return {
-    kind: "audio_frame" as const,
-    contextId,
-    timestampMs: 1520,
-    audio: new Int16Array(320),
-  };
-}
-
-describe("SmartTurnInteractionPolicy", () => {
-  it("selects the Silero-boundary + Smart Turn + semantic fusion path", async () => {
-    const predictor = new PredictableSmartTurn([1]);
-    const policy = new SmartTurnInteractionPolicy(predictor);
-    await policy.initialize();
-
-    policy.observe(speechStarted());
-    policy.observe({
-      kind: "stt_partial",
-      contextId: "turn-1",
-      timestampMs: 1400,
-      text: "What are your office hours?",
-    });
-    policy.observe(speechEnded());
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(policy.observe(audioFrame())).toEqual([
-      { kind: "take_turn", confidence: 1, waitMs: 150 },
-    ]);
-    await policy.close();
-    expect(predictor.initialized).toBe(true);
-    expect(predictor.closed).toBe(true);
-  });
-
-  it("holds an acoustically-complete mid-thought pause, then releases at the safety fallback", async () => {
-    const policy = new SmartTurnInteractionPolicy(new PredictableSmartTurn([1]));
-    await policy.initialize({ semantic_defer_fallback_ms: 1 });
-
-    policy.observe(speechStarted("turn-hold"));
-    policy.observe({
-      kind: "stt_partial",
-      contextId: "turn-hold",
-      timestampMs: 1400,
-      text: "I need to know",
-    });
-    policy.observe(speechEnded("turn-hold"));
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    expect(policy.observe(audioFrame("turn-hold"))).toEqual([{ kind: "hold" }]);
-
-    await new Promise((resolve) => setTimeout(resolve, 5));
-    expect(policy.observe(audioFrame("turn-hold"))).toEqual([
-      { kind: "take_turn", confidence: 0, waitMs: 0 },
-    ]);
-    await policy.close();
-  });
-
-  it("uses high-confidence semantics to shortcut an uncertain acoustic result", async () => {
-    const policy = new SmartTurnInteractionPolicy(new PredictableSmartTurn([0.1]));
-    await policy.initialize();
-
-    policy.observe(speechStarted("turn-shortcut"));
-    policy.observe({
-      kind: "stt_partial",
-      contextId: "turn-shortcut",
-      timestampMs: 1400,
-      text: "What are your office hours?",
-    });
-    policy.observe(speechEnded("turn-shortcut"));
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(policy.observe(audioFrame("turn-shortcut"))).toEqual([
-      { kind: "take_turn", confidence: 0.9, waitMs: 335 },
-    ]);
-    await policy.close();
-  });
-
-  it("keeps synchronous audio-frame observation p99 within 5ms", async () => {
-    const policy = new SmartTurnInteractionPolicy(new PredictableSmartTurn([]));
-    await policy.initialize({ max_audio_samples: 16000 });
-    policy.observe(speechStarted("turn-bench"));
-
-    const durations: number[] = [];
-    for (let index = 0; index < 1000; index += 1) {
-      const startedAt = performance.now();
-      policy.observe(audioFrame("turn-bench"));
-      durations.push(performance.now() - startedAt);
-    }
-    durations.sort((left, right) => left - right);
-    const p99 = durations[Math.floor(durations.length * 0.99) - 1] ?? Infinity;
-    expect(p99).toBeLessThanOrEqual(5);
-    await policy.close();
-  });
-});

package/src/semantic-completeness.test.ts

@@ -1,164 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import {
-  fuseEndpointDecision,
-  scoreSemanticCompleteness,
-  type SemanticEndpointFusionConfig,
-} from "./semantic-completeness.js";
-import { SEMANTIC_LABELED_UTTERANCES } from "./semantic-fixtures.js";
-
-const fusionConfig: SemanticEndpointFusionConfig = {
-  enabled: true,
-  finalizeDelayMs: 250,
-  semanticShortcutDelayMs: 50,
-  incompleteFallbackMs: 2000,
-};
-
-describe("scoreSemanticCompleteness", () => {
-  it("labels complete utterances as complete", () => {
-    for (const fixture of SEMANTIC_LABELED_UTTERANCES.filter((item) => item.category === "complete")) {
-      const score = scoreSemanticCompleteness(fixture.text);
-      expect(score.complete, fixture.id).toBe(true);
-      expect(score.label).toBe("complete");
-    }
-  });
-
-  it("labels mid-thought pauses as incomplete", () => {
-    for (const fixture of SEMANTIC_LABELED_UTTERANCES.filter(
-      (item) => item.category === "mid_thought_pause",
-    )) {
-      const score = scoreSemanticCompleteness(fixture.text);
-      expect(score.complete, fixture.id).toBe(false);
-      expect(score.label).toBe("incomplete");
-    }
-  });
-
-  it("does not treat word count alone as a complete turn", () => {
-    const score = scoreSemanticCompleteness("I was wondering if I can still add biology");
-    expect(score.complete).toBe(false);
-    expect(score.label).toBe("incomplete");
-  });
-
-  it("labels backchannels as complete turns", () => {
-    for (const fixture of SEMANTIC_LABELED_UTTERANCES.filter((item) => item.category === "backchannel")) {
-      const score = scoreSemanticCompleteness(fixture.text);
-      expect(score.complete, fixture.id).toBe(true);
-      expect(score.label).toBe("backchannel");
-    }
-  });
-});
-
-describe("fuseEndpointDecision", () => {
-  it("releases when Smart Turn and semantics agree on completion", () => {
-    const decision = fuseEndpointDecision(
-      true,
-      scoreSemanticCompleteness("What are your office hours?"),
-      fusionConfig,
-    );
-    expect(decision).toEqual({
-      release: true,
-      requestFinalize: true,
-      finalizeDelayMs: 250,
-    });
-  });
-
-  it("defers when Smart Turn approves but semantics are incomplete", () => {
-    const decision = fuseEndpointDecision(
-      true,
-      scoreSemanticCompleteness("I need to know"),
-      fusionConfig,
-    );
-    expect(decision).toEqual({
-      release: false,
-      requestFinalize: false,
-      finalizeDelayMs: 250,
-      deferReason: "semantic_incomplete",
-    });
-  });
-
-  it("shortcuts only high-confidence semantics when Smart Turn is uncertain", () => {
-    const decision = fuseEndpointDecision(
-      false,
-      scoreSemanticCompleteness("What are your office hours?"),
-      fusionConfig,
-    );
-    expect(decision).toEqual({
-      release: true,
-      requestFinalize: true,
-      finalizeDelayMs: 50,
-      shortcutReason: "semantic_complete",
-    });
-  });
-
-  it("waits for fallback when semantics are weak and Smart Turn is uncertain", () => {
-    const decision = fuseEndpointDecision(
-      false,
-      scoreSemanticCompleteness("I was wondering if I can still add biology"),
-      fusionConfig,
-    );
-    expect(decision).toEqual({
-      release: false,
-      requestFinalize: false,
-      finalizeDelayMs: 2000,
-    });
-  });
-
-  it("waits when both Smart Turn and semantics are incomplete", () => {
-    const decision = fuseEndpointDecision(
-      false,
-      scoreSemanticCompleteness("I need to know"),
-      fusionConfig,
-    );
-    expect(decision).toEqual({
-      release: false,
-      requestFinalize: false,
-      finalizeDelayMs: 2000,
-    });
-  });
-
-  it("falls back to Smart Turn only when semantic endpointing is disabled", () => {
-    const decision = fuseEndpointDecision(
-      true,
-      scoreSemanticCompleteness("I need to know"),
-      { ...fusionConfig, enabled: false },
-    );
-    expect(decision).toEqual({
-      release: true,
-      requestFinalize: true,
-      finalizeDelayMs: 250,
-    });
-  });
-});
-
-describe("labeled fusion outcomes vs Smart-Turn-only", () => {
-  it("releases complete utterances earlier than Smart-Turn-only when acoustics are uncertain", () => {
-    const complete = SEMANTIC_LABELED_UTTERANCES.filter((item) => item.category === "complete");
-    for (const fixture of complete) {
-      const fused = fuseEndpointDecision(false, scoreSemanticCompleteness(fixture.text), fusionConfig);
-      const smartTurnOnly = fuseEndpointDecision(
-        false,
-        scoreSemanticCompleteness(fixture.text),
-        { ...fusionConfig, enabled: false },
-      );
-      expect(fused.release, fixture.id).toBe(true);
-      expect(smartTurnOnly.release, fixture.id).toBe(false);
-      expect(fused.finalizeDelayMs).toBeLessThan(fusionConfig.incompleteFallbackMs);
-    }
-  });
-
-  it("defers mid-thought pauses when Smart Turn would have released", () => {
-    const midThought = SEMANTIC_LABELED_UTTERANCES.filter((item) => item.category === "mid_thought_pause");
-    for (const fixture of midThought) {
-      const fused = fuseEndpointDecision(true, scoreSemanticCompleteness(fixture.text), fusionConfig);
-      const smartTurnOnly = fuseEndpointDecision(
-        true,
-        scoreSemanticCompleteness(fixture.text),
-        { ...fusionConfig, enabled: false },
-      );
-      expect(fused.release, fixture.id).toBe(false);
-      expect(smartTurnOnly.release, fixture.id).toBe(true);
-      expect(fused.deferReason).toBe("semantic_incomplete");
-    }
-  });
-});

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"]
-}