voicecc 1.1.35 → 1.2.0

package/server/voice/audio-inactivity.ts

@@ -1,91 +0,0 @@
-/**
- * Audio inactivity watchdog for streaming connections.
- *
- * Detects when a caller hangs up but the WebSocket doesn't close cleanly.
- * Twilio sends audio frames continuously during an active call (even silence).
- * When frames stop arriving, the call is dead and the onTimeout callback fires
- * so the caller can tear down the session.
- *
- * Responsibilities:
- * - Track timestamps of incoming audio frames via ping()
- * - Periodically check whether audio has gone silent beyond a threshold
- * - Fire a callback when the timeout is exceeded
- * - Clean up the interval timer on dispose
- */
-
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-
-/** Default: close the connection if no audio frames arrive within this window (ms) */
-const DEFAULT_TIMEOUT_MS = 5000;
-
-/** Default: how often to check for audio inactivity (ms) */
-const DEFAULT_CHECK_INTERVAL_MS = 2000;
-
-// ============================================================================
-// INTERFACES
-// ============================================================================
-
-/** Configuration for the audio inactivity watchdog */
-export interface AudioInactivityConfig {
-  /** Time without audio before firing the callback (ms). Default: 5000 */
-  timeoutMs?: number;
-  /** How often to check for inactivity (ms). Default: 2000 */
-  checkIntervalMs?: number;
-  /** Called when the timeout is exceeded */
-  onTimeout: () => void;
-}
-
-/** Handle returned by createAudioInactivityWatchdog */
-export interface AudioInactivityWatchdog {
-  /** Call this when an audio frame arrives to reset the timer */
-  ping: () => void;
-  /** Stop the watchdog and clean up the interval */
-  dispose: () => void;
-}
-
-// ============================================================================
-// MAIN ENTRYPOINT
-// ============================================================================
-
-/**
- * Create an audio inactivity watchdog that fires a callback when no audio
- * frames have arrived within the configured timeout.
- *
- * @param config - Timeout thresholds and callback
- * @returns A watchdog handle with ping() and dispose() methods
- */
-export function createAudioInactivityWatchdog(config: AudioInactivityConfig): AudioInactivityWatchdog {
-  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const checkIntervalMs = config.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
-
-  let lastAudioAt = Date.now();
-  let fired = false;
-
-  const timer = setInterval(() => {
-    if (fired) return;
-
-    const silentMs = Date.now() - lastAudioAt;
-    if (silentMs >= timeoutMs) {
-      fired = true;
-      config.onTimeout();
-    }
-  }, checkIntervalMs);
-
-  /**
-   * Signal that an audio frame was received. Resets the inactivity clock.
-   */
-  function ping(): void {
-    lastAudioAt = Date.now();
-  }
-
-  /**
-   * Stop the watchdog and clean up resources.
-   */
-  function dispose(): void {
-    clearInterval(timer);
-  }
-
-  return { ping, dispose };
-}

package/server/voice/browser-audio-playback.test.ts

@@ -1,149 +0,0 @@
-/**
- * Tests that the AudioWorklet processor plays back all TTS audio without
- * dropping samples, regardless of chunk size or arrival timing.
- *
- * Loads the actual audio-processor.js and exercises it through the same
- * postMessage/process interface the browser uses. Tests outcomes only --
- * no assumptions about internal buffering strategy.
- *
- * Run: npx tsx --test server/voice/browser-audio-playback.test.ts
- */
-
-import { test } from "node:test";
-import { strict as assert } from "node:assert";
-import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ============================================================================
-// HARNESS -- stub browser AudioWorklet APIs so we can load audio-processor.js
-// ============================================================================
-
-function loadProcessor(): {
-  postMessage: (data: Record<string, unknown>) => void;
-  process: (inputs: Float32Array[][], outputs: Float32Array[][]) => boolean;
-} {
-  const source = readFileSync(join(__dirname, "../../dashboard/public/audio-processor.js"), "utf-8");
-
-  let ProcessorClass: any;
-
-  // Stub globals that audio-processor.js expects
-  const globals = {
-    AudioWorkletProcessor: class {
-      port = {
-        onmessage: null as ((event: { data: Record<string, unknown> }) => void) | null,
-        postMessage(_data: unknown) {},
-      };
-    },
-    registerProcessor(_name: string, cls: any) {
-      ProcessorClass = cls;
-    },
-  };
-
-  const fn = new Function(...Object.keys(globals), source);
-  fn(...Object.values(globals));
-
-  const instance = new ProcessorClass();
-
-  return {
-    postMessage(data: Record<string, unknown>) {
-      instance.port.onmessage?.({ data });
-    },
-    process(inputs: Float32Array[][], outputs: Float32Array[][]) {
-      return instance.process(inputs, outputs, {});
-    },
-  };
-}
-
-// ============================================================================
-// TESTS
-// ============================================================================
-
-/**
- * Simulates the exact scenario from the logs:
- *   chunk 0: 2.0s audio at 24kHz -> 96,000 samples at 48kHz
- *   chunk 1: 3.0s audio at 24kHz -> 144,000 samples at 48kHz
- *
- * Both chunks arrive within ~500ms. The process() callback drains 128
- * samples per frame. Between the two chunk arrivals, only ~24,000 samples
- * drain -- far less than the total audio.
- *
- * All 240,000 samples should be played back with no drops.
- */
-test("all TTS audio plays back without drops across multi-second chunks", () => {
-  const proc = loadProcessor();
-  const BROWSER_RATE = 48_000;
-  const FRAME_SIZE = 128;
-
-  // Chunk 0: 2s at 48kHz, filled with 0.5
-  const chunk0 = new Float32Array(2.0 * BROWSER_RATE);
-  chunk0.fill(0.5);
-
-  // Chunk 1: 3s at 48kHz, filled with 0.3
-  const chunk1 = new Float32Array(3.0 * BROWSER_RATE);
-  chunk1.fill(0.3);
-
-  const totalSamples = chunk0.length + chunk1.length; // 240,000
-
-  // Post chunk 0
-  proc.postMessage({ type: "playback", samples: chunk0 });
-
-  // Simulate ~500ms of process() draining between chunk arrivals
-  const framesBetweenChunks = Math.floor((0.5 * BROWSER_RATE) / FRAME_SIZE);
-  let totalNonSilent = 0;
-
-  for (let i = 0; i < framesBetweenChunks; i++) {
-    const output = new Float32Array(FRAME_SIZE);
-    proc.process([[new Float32Array(FRAME_SIZE)]], [[output]]);
-    for (let j = 0; j < output.length; j++) {
-      if (output[j] !== 0) totalNonSilent++;
-    }
-  }
-
-  // Post chunk 1
-  proc.postMessage({ type: "playback", samples: chunk1 });
-
-  // Drain until we get a full frame of silence (queue exhausted)
-  let silentFrames = 0;
-  while (silentFrames < 3) {
-    const output = new Float32Array(FRAME_SIZE);
-    proc.process([[new Float32Array(FRAME_SIZE)]], [[output]]);
-
-    let frameSilent = true;
-    for (let j = 0; j < output.length; j++) {
-      if (output[j] !== 0) {
-        totalNonSilent++;
-        frameSilent = false;
-      }
-    }
-    silentFrames = frameSilent ? silentFrames + 1 : 0;
-  }
-
-  assert.equal(
-    totalNonSilent, totalSamples,
-    `Expected all ${totalSamples} samples (${(totalSamples / BROWSER_RATE).toFixed(1)}s) to play back, ` +
-    `but only ${totalNonSilent} (${(totalNonSilent / BROWSER_RATE).toFixed(1)}s) were non-silent. ` +
-    `${totalSamples - totalNonSilent} samples were dropped.`
-  );
-});
-
-/**
- * Verifies that "clear" discards all pending audio immediately.
- * After clear, process() should output silence.
- */
-test("clear discards all pending audio", () => {
-  const proc = loadProcessor();
-  const FRAME_SIZE = 128;
-
-  proc.postMessage({ type: "playback", samples: new Float32Array(100_000).fill(0.5) });
-  proc.postMessage({ type: "clear" });
-
-  const output = new Float32Array(FRAME_SIZE);
-  proc.process([[new Float32Array(FRAME_SIZE)]], [[output]]);
-
-  for (let i = 0; i < output.length; i++) {
-    assert.equal(output[i], 0, `Expected silence at index ${i} after clear`);
-  }
-});

package/server/voice/browser-audio.ts

@@ -1,147 +0,0 @@
-/**
- * Browser audio adapter for direct WebSocket connections.
- *
- * Implements the AudioAdapter interface for browser-based voice calls by
- * exchanging raw PCM audio over a WebSocket. Simpler than TwilioAudioAdapter --
- * no mulaw codec, no Twilio-specific protocol framing.
- *
- * Responsibilities:
- * - Receive Float32Array PCM at 16kHz from the browser via binary WebSocket messages
- * - Send int16 24kHz PCM as binary WebSocket messages to the browser
- * - Handle backpressure on writeSpeaker via ws.send callback
- * - Send JSON control messages (e.g. "clear" for interruption)
- * - Cache the ready chime as 24kHz PCM for playback
- */
-
-import type { WebSocket } from "ws";
-import type { AudioAdapter } from "./audio-adapter.js";
-
-import { decodeChimeToPcm } from "./chime.js";
-
-// ============================================================================
-// TYPES
-// ============================================================================
-
-/** Configuration for creating a browser audio adapter */
-export interface BrowserAudioAdapterConfig {
-  /** Active WebSocket connection to the browser */
-  ws: WebSocket;
-}
-
-// ============================================================================
-// MAIN ENTRYPOINT
-// ============================================================================
-
-/**
- * Create an AudioAdapter that reads/writes audio over a browser WebSocket connection.
- *
- * Decodes the macOS Glass.aiff chime to raw 24kHz PCM during initialization
- * and caches the buffer for playChime(). The browser sends Float32Array PCM at
- * 16kHz as binary messages, and receives int16 24kHz PCM as binary messages.
- *
- * @param config - Browser WebSocket connection
- * @returns An AudioAdapter for browser audio I/O
- */
-export function createBrowserAudioAdapter(config: BrowserAudioAdapterConfig): AudioAdapter {
-  const { ws } = config;
-
-  let wsClosed = false;
-
-  // Track WebSocket close state
-  ws.on("close", () => {
-    wsClosed = true;
-  });
-
-  // Decode chime to raw 24kHz PCM and cache it
-  const chimePcm = decodeChimeToPcm();
-
-  // --------------------------------------------------------------------------
-  // AudioAdapter methods
-  // --------------------------------------------------------------------------
-
-  /**
-   * Subscribe to incoming audio chunks from the browser.
-   * Registers a WebSocket binary message handler that converts the incoming
-   * Buffer to Float32Array and invokes the callback. Ignores text (JSON) messages.
-   *
-   * @param callback - Called with each audio chunk as Float32Array (16kHz)
-   */
-  function onAudio(callback: (samples: Float32Array) => void): void {
-    ws.on("message", (data: Buffer | string, isBinary: boolean) => {
-      if (wsClosed) return;
-
-      // Only process binary messages (audio data)
-      if (!isBinary) return;
-
-      // Convert Buffer to Float32Array (copy to ensure 4-byte alignment)
-      const buffer = data as Buffer;
-      const aligned = new ArrayBuffer(buffer.byteLength);
-      new Uint8Array(aligned).set(buffer);
-      const float32 = new Float32Array(aligned);
-      callback(float32);
-    });
-  }
-
-  /**
-   * Write PCM audio to the browser via WebSocket.
-   * Sends 24kHz int16 PCM buffer as a binary WebSocket message.
-   * Uses ws.send callback for backpressure -- resolves when the data is flushed.
-   * Silently returns if the WebSocket has closed.
-   *
-   * @param pcm - Raw PCM buffer (16-bit signed, 24kHz mono)
-   * @returns Resolves when the write completes
-   */
-  function writeSpeaker(pcm: Buffer): Promise<void> {
-    if (wsClosed) return Promise.resolve();
-
-    return new Promise<void>((resolve) => {
-      ws.send(pcm, { binary: true }, () => {
-        // Resolve on both success and error -- write errors mean the
-        // connection is closing, and callers should not need to handle that
-        resolve();
-      });
-    });
-  }
-
-  /**
-   * Clear the browser's playback buffer immediately (user interruption).
-   * Sends a JSON "clear" message over the WebSocket.
-   */
-  function interrupt(): void {
-    if (wsClosed) return;
-
-    ws.send(JSON.stringify({ type: "clear" }));
-  }
-
-  /**
-   * Resume output after an interrupt. No-op for browser --
-   * AudioWorklet resumes consuming from ring buffer automatically after clear.
-   */
-  function resume(): void {
-    // No-op: browser AudioWorklet resumes automatically
-  }
-
-  /**
-   * Play the ready chime by sending the cached 24kHz PCM through writeSpeaker.
-   */
-  function playChime(): void {
-    writeSpeaker(chimePcm);
-  }
-
-  /**
-   * Clean up resources. No-op for browser -- WebSocket lifecycle is
-   * managed by browser-server.ts.
-   */
-  function destroy(): void {
-    // No-op: WebSocket lifecycle managed by browser-server.ts
-  }
-
-  return {
-    onAudio,
-    writeSpeaker,
-    interrupt,
-    resume,
-    playChime,
-    destroy,
-  };
-}

package/server/voice/browser-server.ts

@@ -1,311 +0,0 @@
-/**
- * Browser audio WebSocket handlers for the unified voice server.
- *
- * Provides WebSocket upgrade logic for browser-based audio sessions.
- * Used by voice-server.ts which owns the HTTP server.
- *
- * Responsibilities:
- * - Accept WebSocket upgrades on /audio?token=<deviceToken>
- * - Validate device tokens via isValidDeviceToken() (localhost bypasses validation)
- * - Reject duplicate connections for the same device token
- * - Create BrowserAudioAdapter + VoiceSession per connection
- */
-
-import { join } from "path";
-
-import { WebSocketServer } from "ws";
-
-import { createBrowserAudioAdapter } from "./browser-audio.js";
-import { createVoiceSession } from "./voice-session.js";
-import { buildAgentPrompt } from "./prompt-builder.js";
-import { isValidDeviceToken } from "../services/device-pairing.js";
-import { getAgent, AGENTS_DIR } from "../services/agent-store.js";
-import { readEnv } from "../services/env.js";
-
-import type { IncomingMessage } from "http";
-import type { Duplex } from "stream";
-import type { WebSocket } from "ws";
-import type { VoiceSession } from "./voice-session.js";
-import type { TtsProviderConfig, SttProviderConfig } from "./types.js";
-
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-
-/** Interruption threshold for browser calls (lower than Twilio's 2000ms because browser getUserMedia includes AEC) */
-const BROWSER_INTERRUPTION_THRESHOLD_MS = 1500;
-
-/** Default ElevenLabs voice ID (used when not set in .env) */
-const DEFAULT_ELEVENLABS_VOICE_ID = "WrjxnKxK0m1uiaH0uteU";
-
-/** Default ElevenLabs TTS model ID (used when not set in .env) */
-const DEFAULT_ELEVENLABS_MODEL_ID = "eleven_turbo_v2_5";
-
-/** Default ElevenLabs STT model ID (used when not set in .env) */
-const DEFAULT_ELEVENLABS_STT_MODEL_ID = "scribe_v1";
-
-// ============================================================================
-// TYPES
-// ============================================================================
-
-/** Tracks an active browser audio session */
-interface ActiveBrowserSession {
-  /** The device token used for this session */
-  deviceToken: string;
-  /** Voice session handle (null until created) */
-  session: VoiceSession | null;
-  /** Optional agent ID for agent-specific sessions */
-  agentId?: string;
-}
-
-// ============================================================================
-// STATE
-// ============================================================================
-
-/** Active sessions keyed by device token */
-const activeSessions = new Map<string, ActiveBrowserSession>();
-
-// ============================================================================
-// EXPORTED HANDLERS
-// ============================================================================
-
-/**
- * Handle a WebSocket upgrade request for browser audio.
- *
- * Validates that the path is /audio, extracts the device token from the query
- * string, checks authorization (localhost or valid device token), and rejects
- * duplicate connections for the same device token.
- *
- * @param req - HTTP upgrade request
- * @param socket - Underlying TCP socket
- * @param head - First packet of the upgraded stream
- * @param wss - WebSocketServer instance to accept the upgrade
- */
-export function handleBrowserUpgrade(
-  req: IncomingMessage,
-  socket: Duplex,
-  head: Buffer,
-  wss: WebSocketServer,
-): void {
-  const url = new URL(req.url ?? "", `http://${req.headers.host}`);
-
-  // Validate path
-  if (url.pathname !== "/audio") {
-    console.log(`Rejected WebSocket upgrade: invalid path ${url.pathname}`);
-    socket.destroy();
-    return;
-  }
-
-  // Extract device token from query string
-  const token = url.searchParams.get("token") ?? "";
-
-  // Check authorization: localhost bypasses token validation
-  const remoteAddr = req.socket.remoteAddress ?? "";
-  const isLocalhost =
-    remoteAddr === "127.0.0.1" ||
-    remoteAddr === "::1" ||
-    remoteAddr === "::ffff:127.0.0.1";
-
-  if (!isLocalhost && !token) {
-    console.log("Rejected WebSocket upgrade: missing device token");
-    socket.destroy();
-    return;
-  }
-
-  if (!isLocalhost && !isValidDeviceToken(token)) {
-    console.log("Rejected WebSocket upgrade: invalid device token");
-    socket.destroy();
-    return;
-  }
-
-  // Reject duplicate connections for the same device token
-  if (token && activeSessions.has(token)) {
-    console.log(`Rejected WebSocket upgrade: duplicate device token ${token}`);
-    socket.destroy();
-    return;
-  }
-
-  // Extract optional agentId from query params
-  const agentId = url.searchParams.get("agentId") || undefined;
-
-  // Accept the WebSocket connection
-  wss.handleUpgrade(req, socket, head, (ws: WebSocket) => {
-    wss.emit("connection", ws, req);
-    handleBrowserSession(ws, token || "localhost", agentId);
-  });
-}
-
-// ============================================================================
-// INTERNAL HANDLERS
-// ============================================================================
-
-/**
- * Handle a connected browser audio WebSocket session.
- *
- * Creates a BrowserAudioAdapter and VoiceSession with browser-tuned config.
- * Registers close/error handlers for cleanup. Removes from activeSessions
- * on disconnect.
- *
- * @param ws - Connected WebSocket for browser audio
- * @param deviceToken - Device token identifying this connection
- * @param agentId - Optional agent ID for agent-specific sessions
- */
-function handleBrowserSession(ws: WebSocket, deviceToken: string, agentId?: string): void {
-  let cleaned = false;
-
-  // Register in active sessions
-  const entry: ActiveBrowserSession = { deviceToken, session: null, agentId };
-  activeSessions.set(deviceToken, entry);
-
-  console.log(`Browser session connected, token: ${deviceToken}`);
-
-  /**
-   * Clean up the browser session. Stops the voice session and removes from
-   * the activeSessions map. Uses cleaned flag to prevent double-cleanup.
-   */
-  async function cleanup(): Promise<void> {
-    if (cleaned) return;
-    cleaned = true;
-
-    if (entry.session) {
-      await entry.session.stop();
-    }
-
-    activeSessions.delete(deviceToken);
-    console.log(`Browser session cleaned up, token: ${deviceToken}`);
-  }
-
-  // WebSocket close handler
-  ws.on("close", () => {
-    cleanup().catch((err) => {
-      console.error(`Error during browser session cleanup: ${err}`);
-    });
-  });
-
-  ws.on("error", (err) => {
-    console.error(`WebSocket error for token ${deviceToken}: ${err}`);
-  });
-
-  // Create adapter and voice session
-  createSession(ws, entry).catch((err) => {
-    console.error(`Failed to create voice session for token ${deviceToken}: ${err}`);
-    ws.close();
-  });
-}
-
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-
-/**
- * Build provider config by reading the latest values from .env.
- * Called per-session so changes to API keys, voice IDs, or model IDs
- * take effect without a server restart.
- *
- * @returns TTS and STT provider configs with current .env values
- */
-async function buildProviderConfig(): Promise<{ ttsProvider: TtsProviderConfig; sttProvider: SttProviderConfig }> {
-  const env = await readEnv();
-
-  const apiKey = env.ELEVENLABS_API_KEY ?? "";
-  const voiceId = env.ELEVENLABS_VOICE_ID ?? DEFAULT_ELEVENLABS_VOICE_ID;
-  const modelId = env.ELEVENLABS_MODEL_ID ?? DEFAULT_ELEVENLABS_MODEL_ID;
-  const sttModelId = env.ELEVENLABS_STT_MODEL_ID ?? DEFAULT_ELEVENLABS_STT_MODEL_ID;
-
-  return {
-    ttsProvider: { provider: "elevenlabs", elevenlabs: { apiKey, voiceId, modelId } },
-    sttProvider: { provider: "elevenlabs", elevenlabs: { apiKey, modelId: sttModelId } },
-  };
-}
-
-/**
- * Build the default voice session config for browser calls.
- *
- * @param ttsProvider - TTS provider config
- * @param sttProvider - STT provider config
- * @returns Default session config object
- */
-function buildDefaultConfig(ttsProvider: TtsProviderConfig, sttProvider: SttProviderConfig) {
-  return {
-    stopPhrase: "stop listening",
-    ttsProvider,
-    sttProvider,
-    interruptionThresholdMs: BROWSER_INTERRUPTION_THRESHOLD_MS,
-    endpointing: {
-      silenceThresholdMs: 700,
-      maxSilenceBeforeTimeoutMs: 1200,
-      minWordCountForFastPath: 2,
-      enableHaikuFallback: false,
-    },
-    narration: {
-      summaryIntervalMs: 12000,
-    },
-    claudeSession: {
-      allowedTools: [] as string[],
-      permissionMode: "bypassPermissions",
-      systemPrompt:
-        "Respond concisely. You are in voice mode -- your responses will be spoken aloud. Keep answers conversational and brief.",
-    },
-  };
-}
-
-/**
- * Create the BrowserAudioAdapter and VoiceSession for a connected WebSocket.
- * If the session has an agentId, loads the agent config for custom system prompt,
- * voice, and working directory.
- *
- * @param ws - Connected WebSocket for browser audio
- * @param entry - Active session entry to populate with the voice session
- */
-async function createSession(ws: WebSocket, entry: ActiveBrowserSession): Promise<void> {
-  const adapter = createBrowserAudioAdapter({ ws });
-
-  const { ttsProvider, sttProvider } = await buildProviderConfig();
-  const defaultConfig = buildDefaultConfig(ttsProvider, sttProvider);
-
-  // Build session config -- use agent personality if agentId is set, otherwise default
-  let sessionConfig: Parameters<typeof createVoiceSession>[1] = {
-    ...defaultConfig,
-    onSessionEnd: () => ws.close(),
-  };
-
-  if (entry.agentId) {
-    try {
-      const agentPrompt = await buildAgentPrompt(entry.agentId, "voice");
-
-      sessionConfig = {
-        ...defaultConfig,
-        claudeSession: {
-          ...defaultConfig.claudeSession,
-          customSystemPrompt: agentPrompt,
-          cwd: join(AGENTS_DIR, entry.agentId),
-        },
-        onSessionEnd: () => ws.close(),
-      };
-
-      // Override TTS voice if the agent has a preference
-      const agent = await getAgent(entry.agentId);
-      if (agent.config.voice?.elevenlabs) {
-        const voicePref = agent.config.voice.elevenlabs;
-        const overriddenTts: TtsProviderConfig = {
-          ...ttsProvider,
-          elevenlabs: { ...ttsProvider.elevenlabs, voiceId: voicePref.id },
-        };
-        sessionConfig = { ...sessionConfig, ttsProvider: overriddenTts };
-        console.log(`Using voice "${voicePref.name}" (${voicePref.id}) for agent "${entry.agentId}"`);
-      }
-
-      // Set initialPrompt so the agent greets with its personality (skips generic startup PCM)
-      sessionConfig.initialPrompt = "The user just connected via browser. Greet them briefly.";
-
-      console.log(`Browser session using agent "${entry.agentId}" for token ${entry.deviceToken}`);
-    } catch (err) {
-      console.error(`Failed to load agent "${entry.agentId}" for browser session:`, err);
-      ws.close();
-      return;
-    }
-  }
-
-  const session = await createVoiceSession(adapter, sessionConfig);
-  entry.session = session;
-}