@kuralle-syrinx/core 4.1.0 → 4.3.0

package/src/pipeline-bus.test.ts

@@ -1,211 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, it, expect, vi } from "vitest";
-import { PipelineBusImpl, Route, type PipelineBusConfig } from "../src/pipeline-bus.js";
-import type { VoicePacket } from "../src/packets.js";
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function pkt(kind: string, contextId = "ctx-1"): VoicePacket {
-  return { kind, contextId, timestampMs: Date.now() };
-}
-
-function createBus(config?: PipelineBusConfig): PipelineBusImpl {
-  return new PipelineBusImpl(config);
-}
-
-/** Start bus, run fn, stop bus, await drain completion. */
-async function withBus(
-  config: PipelineBusConfig | undefined,
-  fn: (bus: PipelineBusImpl) => void | Promise<void>,
-): Promise<void> {
-  const bus = createBus(config);
-  const startP = bus.start();
-  // Give the start loop a tick to begin
-  await new Promise((r) => setTimeout(r, 5));
-  await fn(bus);
-  // Allow pending dispatches to complete
-  await new Promise((r) => setTimeout(r, 20));
-  bus.stop();
-  await startP;
-}
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-describe("PipelineBusImpl", () => {
-  describe("push and drain order", () => {
-    it("drains Critical before Main", async () => {
-      const processed: string[] = [];
-      await withBus(undefined, (bus) => {
-        bus.on("critical.event", () => { processed.push("critical"); });
-        bus.on("main.event", () => { processed.push("main"); });
-        bus.push(Route.Main, pkt("main.event"));
-        bus.push(Route.Critical, pkt("critical.event"));
-      });
-      expect(processed).toEqual(["critical", "main"]);
-    });
-
-    it("drains Main before Background", async () => {
-      const processed: string[] = [];
-      await withBus(undefined, (bus) => {
-        bus.on("main.event", () => { processed.push("main"); });
-        bus.on("bg.event", () => { processed.push("bg"); });
-        bus.push(Route.Background, pkt("bg.event"));
-        bus.push(Route.Main, pkt("main.event"));
-      });
-      expect(processed).toEqual(["main", "bg"]);
-    });
-
-    it("batches Critical up to criticalBatchSize before yielding", async () => {
-      const processed: string[] = [];
-      await withBus({ criticalBatchSize: 3 }, (bus) => {
-        bus.on("critical.event", () => { processed.push("c"); });
-        for (let i = 0; i < 5; i++) {
-          bus.push(Route.Critical, pkt("critical.event"));
-        }
-      });
-      expect(processed.length).toBeGreaterThanOrEqual(5);
-    });
-  });
-
-  describe("capacity and overflow", () => {
-    it("drops oldest Background on overflow", async () => {
-      const dropped: VoicePacket[] = [];
-      const metrics: string[] = [];
-      await withBus(
-        { bgCapacity: 2, onBackgroundDrop: (d: VoicePacket) => { dropped.push(d); } },
-        (bus) => {
-          bus.on("metric.conversation", (pkt: any) => {
-            metrics.push(pkt.name);
-          });
-          bus.push(Route.Background, pkt("bg.1", "id-1"));
-          bus.push(Route.Background, pkt("bg.2", "id-2"));
-          bus.push(Route.Background, pkt("bg.3", "id-3"));
-        },
-      );
-      expect(dropped.length).toBeGreaterThanOrEqual(1);
-      if (dropped.length > 0) {
-        expect(dropped[0]!.contextId).toBe("id-1");
-      }
-      expect(metrics).toContain("pipeline.bus.background.dropped");
-    });
-
-    it("throws on Main overflow", () => {
-      const bus = createBus({ mainCapacity: 1 });
-      bus.push(Route.Main, pkt("main.1"));
-      expect(() => bus.push(Route.Main, pkt("main.2"))).toThrow("Main queue full");
-    });
-
-    it("Critical never overflows", () => {
-      const bus = createBus();
-      for (let i = 0; i < 10000; i++) {
-        bus.push(Route.Critical, pkt("critical.event"));
-      }
-      expect(true).toBe(true);
-    });
-  });
-
-  describe("handler registration", () => {
-    it("calls matching handler for packet kind", async () => {
-      const fn = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", fn);
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it("does not call handler for different kind", async () => {
-      const fn = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", fn);
-        bus.push(Route.Main, pkt("other.event"));
-      });
-      expect(fn).not.toHaveBeenCalled();
-    });
-
-    it("unsubscribe removes handler", async () => {
-      const fn = vi.fn();
-      await withBus(undefined, (bus) => {
-        const unsub = bus.on("test.event", fn);
-        unsub();
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(fn).not.toHaveBeenCalled();
-    });
-
-    it("multiple handlers for same kind all fire", async () => {
-      const fn1 = vi.fn();
-      const fn2 = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", fn1);
-        bus.on("test.event", fn2);
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(fn1).toHaveBeenCalledTimes(1);
-      expect(fn2).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("allPackets", () => {
-    it("publishes every pushed packet with its route", async () => {
-      const bus = createBus();
-      const reader = bus.allPackets.getReader();
-      bus.push(Route.Main, pkt("main.event", "main-1"));
-      bus.push(Route.Critical, pkt("critical.event", "critical-1"));
-
-      const first = await reader.read();
-      const second = await reader.read();
-      reader.releaseLock();
-
-      expect(first.value).toMatchObject({
-        route: Route.Main,
-        packet: { kind: "main.event", contextId: "main-1" },
-      });
-      expect(second.value).toMatchObject({
-        route: Route.Critical,
-        packet: { kind: "critical.event", contextId: "critical-1" },
-      });
-    });
-
-    it("does not retain packets when no reader is attached (drop-on-unread)", async () => {
-      const bus = createBus();
-      // No getReader() → stream unlocked → nothing retained (else a call with no
-      // recorder would buffer every audio packet and OOM).
-      for (let i = 0; i < 1000; i++) bus.push(Route.Main, pkt("main.event", `n-${i}`));
-
-      // A reader that attaches later sees only packets pushed AFTER it attaches.
-      const reader = bus.allPackets.getReader();
-      bus.push(Route.Main, pkt("main.event", "after-reader"));
-      const next = await reader.read();
-      reader.releaseLock();
-      expect(next.value).toMatchObject({ packet: { contextId: "after-reader" } });
-    });
-  });
-
-  describe("error handling", () => {
-    it("handler error pushes VoiceErrorPacket to Critical", async () => {
-      const errorHandler = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", () => { throw new Error("boom"); });
-        bus.on("pipeline.error", errorHandler);
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(errorHandler).toHaveBeenCalled();
-    });
-
-    it("handler error does not stop other handlers", async () => {
-      const fn2 = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", () => { throw new Error("boom"); });
-        bus.on("test.event", fn2);
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(fn2).toHaveBeenCalledTimes(1);
-    });
-  });
-});

package/src/primary-speaker-gate.test.ts

@@ -1,150 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it, vi } from "vitest";
-import {
-  PrimarySpeakerGate,
-  extractSpeakerFingerprint,
-  fingerprintSimilarity,
-} from "./primary-speaker-gate.js";
-import * as primarySpeakerGateModule from "./primary-speaker-gate.js";
-import {
-  ASSISTANT_ECHO_TONE_HZ,
-  BYSTANDER_SPEAKER_TONE_HZ,
-  PRIMARY_SPEAKER_TONE_HZ,
-  mixPcm16,
-  synthesizeTonePcm16,
-} from "./primary-speaker-fixtures.js";
-
-describe("extractSpeakerFingerprint", () => {
-  it("separates distinct synthetic speakers by band shape", () => {
-    const primary = extractSpeakerFingerprint(
-      synthesizeTonePcm16({ frequencyHz: PRIMARY_SPEAKER_TONE_HZ, durationMs: 40 }),
-    );
-    const bystander = extractSpeakerFingerprint(
-      synthesizeTonePcm16({ frequencyHz: BYSTANDER_SPEAKER_TONE_HZ, durationMs: 40 }),
-    );
-    expect(primary).not.toBeNull();
-    expect(bystander).not.toBeNull();
-    const self = fingerprintSimilarity(primary!, primary!);
-    const cross = fingerprintSimilarity(primary!, bystander!);
-    expect(self).toBeGreaterThan(0.95);
-    expect(cross).toBeLessThan(0.72);
-  });
-});
-
-describe("PrimarySpeakerGate", () => {
-  it("commits barge-in for primary-only sustained speech", () => {
-    const gate = new PrimarySpeakerGate();
-    const primary = synthesizeTonePcm16({ frequencyHz: PRIMARY_SPEAKER_TONE_HZ, durationMs: 32 });
-    gate.enrollUserTurnChunk(primary);
-    gate.lockProfileFromFirstTurn();
-    gate.beginBargeInWindow();
-    for (let i = 0; i < 6; i += 1) {
-      gate.observeBargeInChunk(primary);
-    }
-    expect(gate.shouldCommitBargeIn()).toBe(true);
-  });
-
-  it("suppresses bystander sustained speech", () => {
-    const gate = new PrimarySpeakerGate();
-    gate.enrollUserTurnChunk(
-      synthesizeTonePcm16({ frequencyHz: PRIMARY_SPEAKER_TONE_HZ, durationMs: 32 }),
-    );
-    gate.lockProfileFromFirstTurn();
-    gate.beginBargeInWindow();
-    const bystander = synthesizeTonePcm16({ frequencyHz: BYSTANDER_SPEAKER_TONE_HZ, durationMs: 32 });
-    for (let i = 0; i < 8; i += 1) {
-      gate.observeBargeInChunk(bystander);
-    }
-    expect(gate.shouldCommitBargeIn()).toBe(false);
-  });
-
-  it("suppresses assistant echo over primary profile", () => {
-    const gate = new PrimarySpeakerGate();
-    gate.enrollUserTurnChunk(
-      synthesizeTonePcm16({ frequencyHz: PRIMARY_SPEAKER_TONE_HZ, durationMs: 32 }),
-    );
-    gate.lockProfileFromFirstTurn();
-    const echo = synthesizeTonePcm16({
-      frequencyHz: ASSISTANT_ECHO_TONE_HZ,
-      durationMs: 32,
-      amplitude: 0.2,
-    });
-    gate.observeAssistantPlayout(
-      synthesizeTonePcm16({ frequencyHz: ASSISTANT_ECHO_TONE_HZ, durationMs: 32 }),
-    );
-    gate.beginBargeInWindow();
-    for (let i = 0; i < 8; i += 1) {
-      gate.observeBargeInChunk(echo);
-    }
-    expect(gate.shouldCommitBargeIn()).toBe(false);
-  });
-
-  it("falls back to permissive commit when no profile is locked", () => {
-    const gate = new PrimarySpeakerGate();
-    gate.beginBargeInWindow();
-    gate.observeBargeInChunk(
-      synthesizeTonePcm16({ frequencyHz: BYSTANDER_SPEAKER_TONE_HZ, durationMs: 32 }),
-    );
-    expect(gate.hasProfile()).toBe(false);
-    expect(gate.shouldCommitBargeIn()).toBe(true);
-  });
-
-  it("commits barge-in when primary similarity beats echo even above threshold", () => {
-    const gate = new PrimarySpeakerGate({ similarityThreshold: 0.72, echoDominanceMargin: 0.12 });
-    const primary = synthesizeTonePcm16({ frequencyHz: PRIMARY_SPEAKER_TONE_HZ, durationMs: 32 });
-    gate.enrollUserTurnChunk(primary);
-    gate.lockProfileFromFirstTurn();
-    gate.observeAssistantPlayout(
-      synthesizeTonePcm16({ frequencyHz: ASSISTANT_ECHO_TONE_HZ, durationMs: 32 }),
-    );
-
-    const profile = (gate as unknown as { profile: NonNullable<ReturnType<typeof extractSpeakerFingerprint>> }).profile;
-    const assistantProfile = (gate as unknown as {
-      assistantProfile: NonNullable<ReturnType<typeof extractSpeakerFingerprint>>;
-    }).assistantProfile;
-
-    vi.spyOn(primarySpeakerGateModule, "fingerprintSimilarity").mockImplementation((_frame, reference) => {
-      if (reference === profile) return 0.95;
-      if (reference === assistantProfile) return 0.73;
-      return 0;
-    });
-
-    gate.beginBargeInWindow();
-    for (let i = 0; i < 6; i += 1) {
-      gate.observeBargeInChunk(primary);
-    }
-    expect(gate.shouldCommitBargeIn()).toBe(true);
-    vi.restoreAllMocks();
-  });
-
-  it("allows mixed audio when primary dominates", () => {
-    const gate = new PrimarySpeakerGate();
-    const primary = synthesizeTonePcm16({ frequencyHz: PRIMARY_SPEAKER_TONE_HZ, durationMs: 32 });
-    gate.enrollUserTurnChunk(primary);
-    gate.lockProfileFromFirstTurn();
-    const mixed = mixPcm16(
-      [
-        synthesizeTonePcm16({ frequencyHz: PRIMARY_SPEAKER_TONE_HZ, durationMs: 32 }),
-        synthesizeTonePcm16({ frequencyHz: BYSTANDER_SPEAKER_TONE_HZ, durationMs: 32, amplitude: 0.08 }),
-      ],
-      [1, 1],
-    );
-    gate.beginBargeInWindow();
-    for (let i = 0; i < 6; i += 1) {
-      gate.observeBargeInChunk(mixed);
-    }
-    expect(gate.shouldCommitBargeIn()).toBe(true);
-  });
-
-  it("mixes PCM chunks whose byteOffset is odd", () => {
-    const primary = synthesizeTonePcm16({ frequencyHz: PRIMARY_SPEAKER_TONE_HZ, durationMs: 32 });
-    const backing = new Uint8Array(primary.byteLength + 1);
-    backing.set(primary, 1);
-    const oddOffsetPrimary = backing.subarray(1);
-    expect(oddOffsetPrimary.byteOffset % 2).toBe(1);
-
-    expect(() => mixPcm16([oddOffsetPrimary], [1])).not.toThrow();
-    expect(mixPcm16([oddOffsetPrimary], [1])).toEqual(primary);
-  });
-});

package/src/provider-fallback.test.ts

@@ -1,87 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import { PipelineBusImpl } from "./pipeline-bus.js";
-import { ProviderFallback, type FallbackProvider } from "./provider-fallback.js";
-import type { ConversationMetricPacket } from "./packets.js";
-
-function provider(
-  id: string,
-  send: FallbackProvider<string, string>["send"],
-  healthProbe: FallbackProvider<string, string>["healthProbe"] = async () => true,
-): FallbackProvider<string, string> {
-  return { id, send, healthProbe };
-}
-
-describe("ProviderFallback", () => {
-  it("falls through unavailable providers and emits availability metrics", async () => {
-    const bus = new PipelineBusImpl();
-    const started = bus.start();
-    const metrics: ConversationMetricPacket[] = [];
-    bus.on("metric.conversation", (pkt) => {
-      metrics.push(pkt as ConversationMetricPacket);
-    });
-    const first = provider("stt.primary", async () => {
-      throw new Error("primary down");
-    });
-    const second = provider("stt.backup", async (req) => `backup:${req}`);
-    const fallback = new ProviderFallback([first, second], {
-      bus,
-      contextId: "turn-1",
-      attemptTimeoutMs: 100,
-      recoveryProbeIntervalMs: 1000,
-    });
-
-    await expect(fallback.send("hello")).resolves.toBe("backup:hello");
-    await new Promise((resolve) => setTimeout(resolve, 10));
-
-    expect(metrics).toContainEqual(expect.objectContaining({
-      contextId: "turn-1",
-      name: "stt.primary.availability_changed",
-      value: "unavailable",
-    }));
-
-    fallback.close();
-    bus.stop();
-    await started;
-  });
-
-  it("runs background recovery probes and returns recovered providers to service", async () => {
-    const bus = new PipelineBusImpl();
-    const started = bus.start();
-    const metrics: ConversationMetricPacket[] = [];
-    bus.on("metric.conversation", (pkt) => {
-      metrics.push(pkt as ConversationMetricPacket);
-    });
-    let primaryHealthy = false;
-    const first = provider(
-      "tts.primary",
-      async () => {
-        if (!primaryHealthy) throw new Error("primary down");
-        return "primary";
-      },
-      async () => primaryHealthy,
-    );
-    const second = provider("tts.backup", async () => "backup");
-    const fallback = new ProviderFallback([first, second], {
-      bus,
-      contextId: "turn-2",
-      attemptTimeoutMs: 100,
-      recoveryProbeIntervalMs: 10,
-    });
-
-    await expect(fallback.send("hello")).resolves.toBe("backup");
-    primaryHealthy = true;
-    await new Promise((resolve) => setTimeout(resolve, 40));
-    await expect(fallback.send("hello")).resolves.toBe("primary");
-
-    expect(metrics).toContainEqual(expect.objectContaining({
-      name: "tts.primary.availability_changed",
-      value: "available",
-    }));
-
-    fallback.close();
-    bus.stop();
-    await started;
-  });
-});

package/src/reasoner.test.ts

@@ -1,69 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Compile-guard: pins the ReasoningPart union shape without runtime consumers.
-
-import { describe, expect, it } from "vitest";
-
-import type { Reasoner, ReasonerMessage, ReasonerTurn, ReasoningPart } from "./reasoner.js";
-
-describe("Reasoner seam types", () => {
-  it("reasoner_union_compile_guard", async () => {
-    const userMsg = { role: "user", content: "hi" } satisfies ReasonerMessage;
-
-    const turn: ReasonerTurn = {
-      userText: "hi",
-      messages: [userMsg],
-      signal: new AbortController().signal,
-    };
-
-    const textDeltaPart = { type: "text-delta", text: "hello" } satisfies ReasoningPart;
-    const toolCallPart = {
-      type: "tool-call",
-      toolId: "tool-1",
-      toolName: "doThing",
-      args: { input: 123 },
-    } satisfies ReasoningPart;
-    const toolResultPart = {
-      type: "tool-result",
-      toolId: "tool-1",
-      toolName: "doThing",
-      result: "ok",
-    } satisfies ReasoningPart;
-    const suspendedPart = {
-      type: "suspended",
-      runId: "run-1",
-      toolId: "tool-1",
-      prompt: "Pause for human-in-the-loop.",
-      payload: { step: 3 },
-    } satisfies ReasoningPart;
-    const errorPart = {
-      type: "error",
-      cause: new Error("backend exploded"),
-      recoverable: true,
-    } satisfies ReasoningPart;
-    const finishPart = { type: "finish", reason: "stop", text: "done" } satisfies ReasoningPart;
-
-    const emptyStream = async function*(): AsyncIterable<ReasoningPart> {
-      // Intentionally empty: this is purely a type-level compile guard.
-    };
-
-    const reasoner: Reasoner = {
-      stream: (_turn: ReasonerTurn): AsyncIterable<ReasoningPart> => emptyStream(),
-    };
-
-    const collected: ReasoningPart[] = [];
-    for await (const part of reasoner.stream(turn)) {
-      collected.push(part);
-    }
-
-    expect(collected).toEqual([]);
-    expect(textDeltaPart).toBeDefined();
-    expect(toolCallPart).toBeDefined();
-    expect(toolResultPart).toBeDefined();
-    expect(suspendedPart).toBeDefined();
-    expect(errorPart).toBeDefined();
-    expect(finishPart).toBeDefined();
-    expect(reasoner).toBeDefined();
-  });
-});
-

package/src/retry.test.ts

@@ -1,83 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it, vi } from "vitest";
-
-import { DEFAULT_RETRY_CONFIG, VOICE_PROVIDER_OUTAGE_RETRY_CONFIG, VOICE_PROVIDER_RETRY_CONFIG, readProviderRetryConfig, readRetryConfig, retryDelayMs, retryDelayWithJitterMs, waitForRetryDelay } from "./retry.js";
-
-describe("retry helpers", () => {
-  it("reads bounded retry config from plugin config", () => {
-    expect(
-      readRetryConfig({
-        retry_max_attempts: 5,
-        retry_base_delay_ms: 100,
-        retry_max_delay_ms: 900,
-      }),
-    ).toEqual({
-      maxAttempts: 5,
-      baseDelayMs: 100,
-      maxDelayMs: 900,
-    });
-  });
-
-  it("backs off exponentially up to the configured cap", () => {
-    const config = {
-      maxAttempts: 5,
-      baseDelayMs: 100,
-      maxDelayMs: 250,
-    };
-    expect(retryDelayMs(1, config)).toBe(100);
-    expect(retryDelayMs(2, config)).toBe(200);
-    expect(retryDelayMs(3, config)).toBe(250);
-  });
-
-  it("applies equal jitter: half the deterministic delay plus a random half", () => {
-    const config = { maxAttempts: 5, baseDelayMs: 100, maxDelayMs: 1000 };
-    // attempt 2 deterministic = 200 → equal-jitter range [100, 200].
-    expect(retryDelayWithJitterMs(2, config, () => 0)).toBe(100);
-    expect(retryDelayWithJitterMs(2, config, () => 1)).toBe(200);
-    expect(retryDelayWithJitterMs(2, config, () => 0.5)).toBe(150);
-  });
-
-  it("can be aborted while waiting", async () => {
-    vi.useFakeTimers();
-    const controller = new AbortController();
-    const wait = waitForRetryDelay(
-      1,
-      {
-        maxAttempts: 3,
-        baseDelayMs: 1000,
-        maxDelayMs: 1000,
-      },
-      controller.signal,
-    );
-
-    controller.abort();
-    await expect(wait).rejects.toMatchObject({ name: "AbortError" });
-    vi.useRealTimers();
-  });
-
-  it("voice-provider profile keeps fast first reconnect but raises the backoff cap", () => {
-    // Fast first reconnect (no multi-second floor → no dead air on transient blips)...
-    expect(retryDelayMs(1, VOICE_PROVIDER_RETRY_CONFIG)).toBe(250);
-    expect(retryDelayMs(1, VOICE_PROVIDER_RETRY_CONFIG)).toBe(DEFAULT_RETRY_CONFIG.baseDelayMs);
-    // ...but a patient cap for persistent provider failure (vs the 2s default).
-    expect(retryDelayMs(10, VOICE_PROVIDER_RETRY_CONFIG)).toBe(10_000);
-    expect(VOICE_PROVIDER_RETRY_CONFIG.maxAttempts).toBeGreaterThan(DEFAULT_RETRY_CONFIG.maxAttempts);
-  });
-
-  it("readProviderRetryConfig defaults to the voice-provider profile but honors overrides", () => {
-    expect(readProviderRetryConfig({})).toEqual(VOICE_PROVIDER_RETRY_CONFIG);
-    expect(readProviderRetryConfig({ retry_max_delay_ms: 3000 }).maxDelayMs).toBe(3000);
-    // The plain default profile is unchanged (intra-turn low-latency retries).
-    expect(readRetryConfig({})).toEqual(DEFAULT_RETRY_CONFIG);
-  });
-
-  it("offers a provider-outage profile with a 4s floor and 10s cap", () => {
-    expect(retryDelayMs(1, VOICE_PROVIDER_OUTAGE_RETRY_CONFIG)).toBe(4_000);
-    expect(retryDelayMs(2, VOICE_PROVIDER_OUTAGE_RETRY_CONFIG)).toBe(8_000);
-    expect(retryDelayMs(3, VOICE_PROVIDER_OUTAGE_RETRY_CONFIG)).toBe(10_000);
-    expect(readProviderRetryConfig({ retry_profile: "provider_outage" })).toEqual(VOICE_PROVIDER_OUTAGE_RETRY_CONFIG);
-    expect(readProviderRetryConfig({ retry_profile: "provider_outage", retry_base_delay_ms: 5000 }).baseDelayMs).toBe(5000);
-    expect(readRetryConfig({})).toEqual(DEFAULT_RETRY_CONFIG);
-  });
-});