@kuralle-syrinx/core 4.1.0 → 4.3.0

package/src/policies/rule-based.ts

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: MIT
+
+import type { PipelineBus } from "../pipeline-bus.js";
+import type { InteractionDecision, InteractionObservation, InteractionPolicy } from "../interaction-policy.js";
+import { PrimarySpeakerGate } from "../primary-speaker-gate.js";
+import { TtsPlayoutClock } from "../tts-playout-clock.js";
+import { TurnArbiter } from "../turn-arbiter.js";
+
+export interface RuleBasedInteractionPolicyDeps {
+  readonly bus: PipelineBus;
+  readonly primarySpeakerGate: PrimarySpeakerGate;
+  readonly ttsPlayout: TtsPlayoutClock;
+  readonly minInterruptionMs: number;
+  /** When true, the underlying TurnArbiter emits duck/resume signals during barge-in evaluation. */
+  readonly pauseThenResolveBargeIn?: boolean;
+  /** Tenant-level backchannel knobs. Default (undefined) = current behavior (`mm_hmm`). */
+  readonly backchannel?: {
+    readonly enabled?: boolean;
+    readonly cues?: readonly string[];
+  };
+}
+
+export class RuleBasedInteractionPolicy implements InteractionPolicy {
+  readonly arbiter: TurnArbiter;
+  private readonly ttsPlayout: TtsPlayoutClock;
+  private readonly backchannelConfig: RuleBasedInteractionPolicyDeps["backchannel"];
+  private pending: InteractionDecision[] = [];
+  private bargeInAudioConsumed = false;
+  private delegateGapOpen = false;
+  private delegateCuePlayed = false;
+  private userSpeaking = false;
+
+  constructor(deps: RuleBasedInteractionPolicyDeps) {
+    this.ttsPlayout = deps.ttsPlayout;
+    this.backchannelConfig = deps.backchannel;
+    this.arbiter = new TurnArbiter({
+      bus: deps.bus,
+      primarySpeakerGate: deps.primarySpeakerGate,
+      ttsPlayout: deps.ttsPlayout,
+      minInterruptionMs: deps.minInterruptionMs,
+      pauseThenResolveBargeIn: deps.pauseThenResolveBargeIn,
+      onInterrupt: (id) => this.pending.push({ kind: "interrupt", interruptedContextId: id }),
+    });
+  }
+
+  observe(obs: InteractionObservation): readonly InteractionDecision[] {
+    switch (obs.kind) {
+      case "vad_speech_started":
+        this.userSpeaking = true;
+        if (obs.interruptedContextId) this.arbiter.onSpeechStarted(
+          {
+            kind: "vad.speech_started",
+            contextId: obs.contextId,
+            timestampMs: obs.timestampMs,
+            confidence: obs.confidence,
+          },
+          obs.interruptedContextId,
+        );
+        break;
+      case "vad_speech_activity":
+        this.arbiter.onSpeechActivity({
+          kind: "vad.speech_activity",
+          contextId: obs.contextId,
+          timestampMs: obs.timestampMs,
+          isAsync: true,
+        });
+        break;
+      case "vad_speech_ended":
+        this.userSpeaking = false;
+        this.arbiter.onSpeechEnded(
+          {
+            kind: "vad.speech_ended",
+            contextId: obs.contextId,
+            timestampMs: obs.timestampMs,
+          },
+          obs.hasActiveTts,
+        );
+        break;
+      case "vad_barge_in_audio":
+        this.bargeInAudioConsumed = this.arbiter.observeBargeInAudio({
+          kind: "vad.audio",
+          contextId: obs.contextId,
+          timestampMs: obs.timestampMs,
+          audio: obs.audio,
+        });
+        break;
+      case "stt_partial":
+        this.arbiter.noteInterimEvidence(obs.text);
+        if (obs.interruptedContextId) {
+          this.arbiter.onProviderSttEvidence(obs.contextId, obs.timestampMs, obs.interruptedContextId);
+        }
+        break;
+      case "stt_final":
+        this.arbiter.noteInterimEvidence(obs.text, obs.confidence);
+        if (obs.interruptedContextId) {
+          this.arbiter.onProviderSttEvidence(obs.contextId, obs.timestampMs, obs.interruptedContextId);
+        }
+        break;
+      case "delegate_state":
+        this.pending.push(...this.handleDelegateState(obs));
+        break;
+      default:
+        break;
+    }
+    if (this.pending.length === 0) return [];
+    const out = this.pending;
+    this.pending = [];
+    return out;
+  }
+
+  private handleDelegateState(obs: InteractionObservation & { kind: "delegate_state" }): InteractionDecision[] {
+    const phase = obs.toolCallPhase;
+    if (!phase) return [];
+
+    switch (phase) {
+      case "started":
+        this.delegateGapOpen = true;
+        this.delegateCuePlayed = false;
+        return [];
+      case "delayed": {
+        if (!this.delegateGapOpen || this.delegateCuePlayed) return [];
+        if (this.depsTtsActive()) return [];
+        if (this.userSpeaking) return [];
+        this.delegateCuePlayed = true;
+        if (this.backchannelConfig?.enabled === false) return [];
+        const cue = this.backchannelConfig?.cues?.[0] ?? "mm_hmm";
+        return [{ kind: "backchannel", cue }];
+      }
+      case "complete":
+      case "failed":
+        this.delegateGapOpen = false;
+        this.delegateCuePlayed = false;
+        return [];
+      default:
+        return [];
+    }
+  }
+
+  private depsTtsActive(): boolean {
+    return this.ttsPlayout.activeContexts().length > 0;
+  }
+
+  reset(_contextId: string): void {
+    this.delegateGapOpen = false;
+    this.delegateCuePlayed = false;
+    this.userSpeaking = false;
+    this.arbiter.clear();
+  }
+
+  takeBargeInAudioConsumed(): boolean {
+    const consumed = this.bargeInAudioConsumed;
+    this.bargeInAudioConsumed = false;
+    return consumed;
+  }
+}

package/src/pricing.ts

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: MIT
+//
+// Versioned price catalog: usage.recorded quantities → USD.
+// Unknown provider/model keys yield unpriced (never silent 0 for real providers).
+// Declared local/self-hosted models are explicitly zero-cost.
+
+import type { UsageRecordedPacket } from "./packets.js";
+
+export interface SttPrice {
+  readonly usdPerAudioSecond: number;
+}
+
+export interface LlmPrice {
+  readonly usdPer1MInputTokens: number;
+  readonly usdPer1MOutputTokens: number;
+  readonly usdPer1MCachedInputTokens?: number;
+}
+
+export interface TtsPrice {
+  readonly usdPer1MCharacters: number;
+}
+
+export interface PriceCatalog {
+  readonly source: string;
+  readonly version: string;
+  /** Keys: `provider/model` (e.g. `deepgram/nova-3`). */
+  readonly stt: Readonly<Record<string, SttPrice>>;
+  readonly llm: Readonly<Record<string, LlmPrice>>;
+  readonly tts: Readonly<Record<string, TtsPrice>>;
+}
+
+export type CostResult =
+  | { readonly usd: number; readonly unpriced?: undefined }
+  | { readonly usd: null; readonly unpriced: true };
+
+function catalogKey(provider: string | undefined, model: string | undefined): string | null {
+  if (!provider || !model) return null;
+  return `${provider}/${model}`;
+}
+
+/**
+ * Public list prices stamped into DEFAULT_PRICE_CATALOG.source.
+ * STT $/audio-second from $/min ÷ 60. TTS is $/1M characters. LLM is $/1M tokens.
+ */
+export const DEFAULT_PRICE_CATALOG: PriceCatalog = {
+  source:
+    "voice-prices@3 | deepgram.com/pricing PAYG Nova-3 streaming monolingual $0.0077/min → $0.000128333/s; " +
+    "deepgram.com/pricing Aura-2 TTS $0.030/1k chars → $30/1M; " +
+    "cartesia.ai/pricing + docs.cartesia.ai/pricing ~1 credit/char, PAYG ~$50/1M chars (cloudtalk.io cartesia-pricing 2026); " +
+    "openai tts-1 $15/1M chars (openai.com api pricing); gpt-4o-mini-tts text $0.60/1M (community/azure listed text input rate); " +
+    "openai GPT-4.1-mini $0.40/$1.60 per 1M in/out (developers.openai.com/api/docs/pricing; Azure GPT-4.1-mini-2025-04-14 Global); " +
+    "cloud.google.com/speech-to-text/pricing V2 standard recognition $0.016/min → $0.000266667/s (latest_long); " +
+    "ai.google.dev/pricing Gemini 2.5 Flash TTS preview text $0.50/1M chars (Gemini API TTS text input rate, 2026); " +
+    "elevenlabs.io/pricing/api Flash/Turbo TTS $0.05/1k chars → $50/1M; Multilingual v2/v3 $0.10/1k → $100/1M; " +
+    "Scribe v2 Realtime $0.39/hour → $0.000108333/s; " +
+    "grok/stt + grok/* TTS + epsilon/epsilon-tts intentionally ABSENT (no public list price → costOf unpriced, never silent $0)",
+  version: "3",
+  stt: {
+    "deepgram/nova-3": { usdPerAudioSecond: 0.0077 / 60 },
+    "deepgram/nova-2": { usdPerAudioSecond: 0.0077 / 60 },
+    "deepgram/flux-general-en": { usdPerAudioSecond: 0.0077 / 60 },
+    // Google Cloud Speech-to-Text V2 standard streaming recognition list rate.
+    "google/latest_long": { usdPerAudioSecond: 0.016 / 60 },
+    "google/latest_short": { usdPerAudioSecond: 0.016 / 60 },
+    "google/chirp_2": { usdPerAudioSecond: 0.016 / 60 },
+    // ElevenLabs Scribe v2 Realtime — public list $0.39/hour.
+    "elevenlabs/scribe_v2_realtime": { usdPerAudioSecond: 0.39 / 3600 },
+    "local/whisper": { usdPerAudioSecond: 0 },
+    // grok/stt: no public list price — omit so costOf → unpriced
+  },
+  llm: {
+    "openai/gpt-4.1-mini": {
+      usdPer1MInputTokens: 0.4,
+      usdPer1MOutputTokens: 1.6,
+      usdPer1MCachedInputTokens: 0.1,
+    },
+    "local/llm": {
+      usdPer1MInputTokens: 0,
+      usdPer1MOutputTokens: 0,
+    },
+  },
+  tts: {
+    "cartesia/sonic-3": { usdPer1MCharacters: 50 },
+    "openai/gpt-4o-mini-tts": { usdPer1MCharacters: 0.6 },
+    "openai/tts-1": { usdPer1MCharacters: 15 },
+    "deepgram/aura-2-thalia-en": { usdPer1MCharacters: 30 },
+    // Gemini TTS preview models — Gemini API TTS text input list rate.
+    "gemini/gemini-3.1-flash-tts-preview": { usdPer1MCharacters: 0.5 },
+    "gemini/gemini-2.5-flash-preview-tts": { usdPer1MCharacters: 0.5 },
+    "gemini/gemini-2.5-pro-preview-tts": { usdPer1MCharacters: 0.5 },
+    // ElevenLabs public list — Flash/Turbo $0.05/1k, Multilingual $0.10/1k.
+    "elevenlabs/eleven_flash_v2_5": { usdPer1MCharacters: 50 },
+    "elevenlabs/eleven_flash_v2": { usdPer1MCharacters: 50 },
+    "elevenlabs/eleven_turbo_v2_5": { usdPer1MCharacters: 50 },
+    "elevenlabs/eleven_turbo_v2": { usdPer1MCharacters: 50 },
+    "elevenlabs/eleven_multilingual_v2": { usdPer1MCharacters: 100 },
+    "local/tts": { usdPer1MCharacters: 0 },
+    // grok/* voice keys + epsilon/epsilon-tts: no public list — omit → unpriced
+  },
+};
+
+export function costOf(usage: UsageRecordedPacket, catalog: PriceCatalog): CostResult {
+  const key = catalogKey(usage.provider, usage.model);
+  if (!key) return { usd: null, unpriced: true };
+
+  switch (usage.stage) {
+    case "stt": {
+      const price = catalog.stt[key];
+      if (!price) return { usd: null, unpriced: true };
+      const seconds = usage.audioSeconds ?? 0;
+      return { usd: seconds * price.usdPerAudioSecond };
+    }
+    case "tts": {
+      const price = catalog.tts[key];
+      if (!price) return { usd: null, unpriced: true };
+      const characters = usage.characters ?? 0;
+      return { usd: (characters / 1_000_000) * price.usdPer1MCharacters };
+    }
+    case "llm": {
+      const price = catalog.llm[key];
+      if (!price) return { usd: null, unpriced: true };
+      const input = usage.inputTokens ?? 0;
+      const output = usage.outputTokens ?? 0;
+      const cached = usage.cachedInputTokens ?? 0;
+      const cachedRate = price.usdPer1MCachedInputTokens ?? price.usdPer1MInputTokens;
+      // Prefer charging cached tokens at the cached rate when present; non-cached input is the remainder.
+      const nonCachedInput = Math.max(0, input - cached);
+      const usd =
+        (nonCachedInput / 1_000_000) * price.usdPer1MInputTokens +
+        (cached / 1_000_000) * cachedRate +
+        (output / 1_000_000) * price.usdPer1MOutputTokens;
+      return { usd };
+    }
+    default:
+      return { usd: null, unpriced: true };
+  }
+}

package/src/primary-speaker-gate.ts

@@ -19,12 +19,23 @@ export interface PrimarySpeakerGateConfig {
   readonly enabled?: boolean;
   readonly similarityThreshold?: number;
   readonly echoDominanceMargin?: number;
+  readonly onDecision?: (decision: PrimarySpeakerGateDecision) => void;
+}
+
+export interface PrimarySpeakerGateDecision {
+  readonly contextId: string;
+  readonly signal: "primary_speaker" | "echo_rejected";
+  readonly accepted: boolean;
+  readonly frameCount: number;
+  readonly primaryHits: number;
+  readonly echoRejectedFrames: number;
 }
 
 export class PrimarySpeakerGate {
   private readonly enabled: boolean;
   private readonly similarityThreshold: number;
   private readonly echoDominanceMargin: number;
+  private readonly onDecision?: PrimarySpeakerGateConfig["onDecision"];
   private profile: SpeakerFingerprint | null = null;
   private enrollFrames: SpeakerFingerprint[] = [];
   private bargeInFrames: SpeakerFingerprint[] = [];
@@ -34,6 +45,7 @@ export class PrimarySpeakerGate {
     this.enabled = config.enabled !== false;
     this.similarityThreshold = config.similarityThreshold ?? 0.72;
     this.echoDominanceMargin = config.echoDominanceMargin ?? 0.12;
+    this.onDecision = config.onDecision;
   }
 
   isEnabled(): boolean {
@@ -73,22 +85,30 @@ export class PrimarySpeakerGate {
     this.assistantProfile = frame;
   }
 
-  shouldCommitBargeIn(): boolean {
+  shouldCommitBargeIn(contextId = ""): boolean {
     if (!this.enabled || this.profile === null) return true;
     if (this.bargeInFrames.length === 0) return false;
 
     let primaryHits = 0;
+    let echoRejectedFrames = 0;
     for (const frame of this.bargeInFrames) {
       const primarySim = fingerprintSimilarity(frame, this.profile);
       if (this.assistantProfile !== null) {
         const echoSim = fingerprintSimilarity(frame, this.assistantProfile);
-        if (echoSim >= primarySim + this.echoDominanceMargin) continue;
+        if (echoSim >= primarySim + this.echoDominanceMargin) {
+          echoRejectedFrames += 1;
+          continue;
+        }
       }
       if (primarySim >= this.similarityThreshold) primaryHits += 1;
     }
 
     const required = Math.max(1, Math.ceil(this.bargeInFrames.length * 0.45));
-    return primaryHits >= required;
+    const accepted = primaryHits >= required;
+    const decision = { contextId, accepted, frameCount: this.bargeInFrames.length, primaryHits, echoRejectedFrames };
+    if (echoRejectedFrames > 0) this.onDecision?.({ signal: "echo_rejected", ...decision });
+    this.onDecision?.({ signal: "primary_speaker", ...decision });
+    return accepted;
   }
 
   resetBargeInWindow(): void {

package/src/reasoner-hedge.ts

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: MIT
+
+import { Route, type PipelineBus } from "./pipeline-bus.js";
+import * as make from "./packet-factories.js";
+import type { Reasoner, ReasonerTurn, ReasoningPart } from "./reasoner.js";
+import { TimerScheduler, type Scheduler } from "./scheduler.js";
+
+export interface HedgedReasonerOptions {
+  readonly primary: Reasoner;
+  readonly backup: Reasoner;
+  readonly hedgeAfterMs: number;
+  readonly bus?: PipelineBus;
+  readonly contextId?: string;
+  readonly scheduler?: Scheduler;
+}
+
+type Backend = "primary" | "backup";
+
+type RacerResult = { who: Backend; result: IteratorResult<ReasoningPart> };
+
+const asRacer = (who: Backend, next: Promise<IteratorResult<ReasoningPart>>): Promise<RacerResult> =>
+  next
+    .then((result) => ({ who, result }))
+    .catch((err): RacerResult => ({
+      who,
+      result: {
+        done: false,
+        value: {
+          type: "error",
+          cause: err instanceof Error ? err : new Error(String(err)),
+          recoverable: true,
+        },
+      },
+    }));
+
+type CommitResult =
+  | { readonly ok: true; readonly winner: Backend; readonly first: ReasoningPart; readonly iter: AsyncIterator<ReasoningPart> }
+  | { readonly ok: false; readonly error: ReasoningPart };
+
+export class HedgedReasoner implements Reasoner {
+  private readonly scheduler: Scheduler;
+
+  constructor(private readonly opts: HedgedReasonerOptions) {
+    this.scheduler = opts.scheduler ?? new TimerScheduler();
+  }
+
+  stream(turn: ReasonerTurn): AsyncIterable<ReasoningPart> {
+    return this.doStream(turn);
+  }
+
+  private async *doStream(turn: ReasonerTurn): AsyncGenerator<ReasoningPart> {
+    const commit = await this.raceToCommit(turn);
+    if (!commit.ok) {
+      yield commit.error;
+      return;
+    }
+
+    yield commit.first;
+    let tail = await commit.iter.next();
+    while (!tail.done) {
+      yield tail.value;
+      tail = await commit.iter.next();
+    }
+  }
+
+  private async raceToCommit(turn: ReasonerTurn): Promise<CommitResult> {
+    const pc = new AbortController();
+    const bc = new AbortController();
+
+    if (turn.signal.aborted) {
+      pc.abort();
+      bc.abort();
+      return { ok: false, error: abortedError() };
+    }
+
+    turn.signal.addEventListener(
+      "abort",
+      () => {
+        pc.abort();
+        bc.abort();
+      },
+      { once: true },
+    );
+
+    let committed = false;
+    let primaryExhausted = false;
+    let backupExhausted = false;
+    let lastError: ReasoningPart | null = null;
+
+    const primaryIter = this.opts.primary.stream({ ...turn, signal: pc.signal })[Symbol.asyncIterator]();
+    let primaryNext: Promise<IteratorResult<ReasoningPart>> = primaryIter.next();
+
+    let backupIter: AsyncIterator<ReasoningPart> | null = null;
+    let backupNext: Promise<IteratorResult<ReasoningPart>> | null = null;
+    let repollRace: (() => void) | null = null;
+
+    const ensureBackup = (): void => {
+      if (backupIter) return;
+      backupIter = this.opts.backup.stream({ ...turn, signal: bc.signal })[Symbol.asyncIterator]();
+      backupNext = backupIter.next();
+      this.metric("hedge.fired", "1");
+      repollRace?.();
+    };
+
+    this.scheduler.schedule("hedge", this.opts.hedgeAfterMs, () => {
+      if (!committed) ensureBackup();
+    });
+
+    while (!committed) {
+      const raced = await new Promise<{ who: Backend; result: IteratorResult<ReasoningPart> } | "repoll">(
+        (resolve) => {
+          const racers: Array<Promise<RacerResult>> = [];
+
+          if (!primaryExhausted) {
+            racers.push(asRacer("primary", primaryNext));
+          }
+          if (backupNext && !backupExhausted) {
+            racers.push(asRacer("backup", backupNext));
+          }
+
+          if (racers.length === 0) {
+            repollRace = null;
+            resolve("repoll");
+            return;
+          }
+
+          repollRace = () => resolve("repoll");
+          void Promise.race(racers).then((winner) => {
+            repollRace = null;
+            resolve(winner);
+          });
+        },
+      );
+
+      if (raced === "repoll") {
+        if (primaryExhausted && (backupExhausted || !backupNext)) {
+          return { ok: false, error: lastError ?? abortedError() };
+        }
+        continue;
+      }
+
+      const { who, result } = raced;
+
+      if (result.done) {
+        if (who === "primary") {
+          primaryExhausted = true;
+          if (!backupIter) {
+            this.scheduler.cancel("hedge");
+            ensureBackup();
+          } else if (backupExhausted) {
+            return { ok: false, error: lastError ?? abortedError() };
+          }
+        } else {
+          backupExhausted = true;
+          if (primaryExhausted) {
+            return { ok: false, error: lastError ?? abortedError() };
+          }
+        }
+        continue;
+      }
+
+      const part = result.value;
+
+      if (part.type === "error") {
+        lastError = part;
+        if (who === "primary") {
+          primaryExhausted = true;
+          if (!backupIter) {
+            this.scheduler.cancel("hedge");
+            ensureBackup();
+          }
+          if (backupExhausted) {
+            return { ok: false, error: part };
+          }
+        } else {
+          backupExhausted = true;
+          if (primaryExhausted) {
+            return { ok: false, error: part };
+          }
+        }
+        continue;
+      }
+
+      committed = true;
+      this.scheduler.cancel("hedge");
+
+      if (who === "primary") {
+        bc.abort();
+        releaseIterator(backupIter);
+        this.metric("hedge.committed_to", "primary");
+        return { ok: true, winner: "primary", first: part, iter: primaryIter };
+      }
+
+      pc.abort();
+      releaseIterator(primaryIter);
+      this.metric("hedge.committed_to", "backup");
+      return { ok: true, winner: "backup", first: part, iter: backupIter! };
+    }
+
+    return { ok: false, error: lastError ?? abortedError() };
+  }
+
+  private metric(name: string, value: string): void {
+    this.opts.bus?.push(Route.Background, make.metric(this.opts.contextId ?? "", name, value));
+  }
+}
+
+function releaseIterator(iter: AsyncIterator<ReasoningPart> | null): void {
+  if (!iter) return;
+  const release = iter.return;
+  if (release) void release.call(iter, undefined);
+}
+
+function abortedError(): ReasoningPart {
+  return { type: "error", cause: new Error("aborted"), recoverable: true };
+}

package/src/reasoner-route.ts

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: MIT
+
+import { Route, type PipelineBus } from "./pipeline-bus.js";
+import * as make from "./packet-factories.js";
+import type { Reasoner, ReasonerTurn, ReasoningPart } from "./reasoner.js";
+
+export interface ReasonerRoute {
+  readonly id: string;
+  readonly reasoner: Reasoner;
+}
+
+export interface RoutingReasonerOptions {
+  readonly routes: readonly ReasonerRoute[];
+  readonly classify: (turn: ReasonerTurn) => string | Promise<string>;
+  readonly speculateRouteId?: string;
+  readonly bus?: PipelineBus;
+  readonly contextId?: string;
+}
+
+export class RoutingReasoner implements Reasoner {
+  constructor(private readonly opts: RoutingReasonerOptions) {}
+
+  stream(turn: ReasonerTurn): AsyncIterable<ReasoningPart> {
+    return this.doStream(turn);
+  }
+
+  private async *doStream(turn: ReasonerTurn): AsyncGenerator<ReasoningPart> {
+    if (turn.signal.aborted) return;
+
+    if (this.opts.speculateRouteId !== undefined) {
+      yield* this.streamWithSpeculation(turn);
+      return;
+    }
+
+    const routeId = await this.opts.classify(turn);
+    const route = this.resolveRoute(routeId);
+    this.metric("route.selected", routeId);
+    const iter = route.reasoner.stream({ ...turn, signal: turn.signal })[Symbol.asyncIterator]();
+    yield* this.forwardRoute(iter, undefined, turn.signal);
+  }
+
+  private async *streamWithSpeculation(turn: ReasonerTurn): AsyncGenerator<ReasoningPart> {
+    const specId = this.opts.speculateRouteId!;
+    const specRoute = this.resolveRoute(specId);
+
+    const child = new AbortController();
+    if (turn.signal.aborted) {
+      child.abort();
+      return;
+    }
+    turn.signal.addEventListener("abort", () => child.abort(), { once: true });
+
+    const specIter = specRoute.reasoner.stream({ ...turn, signal: child.signal })[Symbol.asyncIterator]();
+    const specNext = specIter.next();
+
+    const classifiedId = await this.opts.classify(turn);
+
+    if (classifiedId === specId) {
+      this.metric("route.selected", classifiedId);
+      yield* this.forwardRoute(specIter, specNext, turn.signal);
+      return;
+    }
+
+    child.abort();
+    releaseIterator(specIter);
+    void specNext.catch(() => undefined);
+    this.metric("route.mispredict", "1");
+
+    const route = this.resolveRoute(classifiedId);
+    this.metric("route.selected", classifiedId);
+    const iter = route.reasoner.stream({ ...turn, signal: turn.signal })[Symbol.asyncIterator]();
+    yield* this.forwardRoute(iter, undefined, turn.signal);
+  }
+
+  private async *forwardRoute(
+    iter: AsyncIterator<ReasoningPart>,
+    first: Promise<IteratorResult<ReasoningPart>> | undefined,
+    signal: AbortSignal,
+  ): AsyncGenerator<ReasoningPart> {
+    try {
+      let next = first ? await first : await iter.next();
+      while (!next.done) {
+        if (signal.aborted) return;
+        yield next.value;
+        next = await iter.next();
+      }
+    } catch (err) {
+      yield {
+        type: "error",
+        cause: err instanceof Error ? err : new Error(String(err)),
+        recoverable: true,
+      };
+    }
+  }
+
+  private resolveRoute(id: string): ReasonerRoute {
+    const route = this.opts.routes.find((r) => r.id === id);
+    if (!route) {
+      throw new Error(`RoutingReasoner: unknown route id "${id}"`);
+    }
+    return route;
+  }
+
+  private metric(name: string, value: string): void {
+    this.opts.bus?.push(Route.Background, make.metric(this.opts.contextId ?? "", name, value));
+  }
+}
+
+function releaseIterator(iter: AsyncIterator<ReasoningPart> | null): void {
+  if (!iter) return;
+  const release = iter.return;
+  if (release) void release.call(iter, undefined);
+}