npm install @reaatech/voice-agent-core @opentelemetry/api
pnpm add @reaatech/voice-agent-core @opentelemetry/api

import { createPipeline, createLatencyBudget, initializeSessionManager } from '@reaatech/voice-agent-core';
 
const sessionManager = initializeSessionManager({
  defaultTTL: 3600,
  maxTurns: 20,
  maxTokens: 4000,
});
 
const latencyEnforcer = new LatencyBudgetEnforcer(
  createLatencyBudget({
    target: 800,
    hardCap: 1200,
    stt: 200,
    mcp: 400,
    tts: 200,
  })
);
 
const pipeline = createPipeline({
  sessionManager,
  latencyEnforcer,
  sttProvider: mySTTProvider,
  ttsProvider: myTTSProvider,
  mcpClient: myMCPClient,
  config: myConfig,
});
 
await pipeline.startSession({ sessionId: 'abc', status: 'active' });
pipeline.on('pipeline:turn:end', (event) => {
  console.log('Turn complete:', event.data.metrics);
});

class Pipeline extends EventEmitter {
  constructor(dependencies: PipelineDependencies);
  startSession(session: { sessionId: string; status: string }): Promise<void>;
  processAudioChunk(sessionId: string, chunk: AudioChunk): Promise<void>;
  bargeIn(sessionId: string): void;
  endSession(sessionId: string): Promise<void>;
  destroy(): void;
}

class SpeechToSpeechPipeline extends EventEmitter {
  startSession(session): Promise<void>;
  processAudioChunk(sessionId, chunk): Promise<void>;
  bargeIn(sessionId): void;
  endSession(sessionId): Promise<void>;
}

class SessionManager {
  constructor(options: SessionManagerOptions);
  createSession(params: { callSid, mcpEndpoint, sttProvider, ttsProvider, metadata? }): Session;
  getSession(sessionId: string): Session | undefined;
  getSessionByCallSid(callSid: string): Session | undefined;
  updateSession(sessionId: string, updates: Partial<Session>): Session | undefined;
  addTurn(sessionId: string, turn: Omit<Turn, 'turnId'>): Turn | undefined;
  getConversationHistory(sessionId: string, maxTurns?: number): Turn[];
  closeSession(sessionId: string): boolean;
  getActiveSessionCount(): number;
  getAllSessions(): Session[];
  destroy(): void;
}

class LatencyBudgetEnforcer extends EventEmitter {
  constructor(budget: LatencyBudget);
  startTurn(turnId: string): void;
  startStage(turnId: string, stage: string): void;
  endStage(turnId: string, stage: string): number;
  endTurn(turnId: string): LatencyMetrics;
  checkStageBudget(stage, elapsedMs): { withinBudget, remainingMs, exceeded };
  checkTotalBudget(elapsedMs): { withinTarget, withinHardCap, remainingTargetMs, remainingHardCapMs };
  getStageBudget(stage: 'stt' | 'mcp' | 'tts'): number;
  getTotalTargetBudget(): number;
  getTotalHardCap(): number;
}

import { defineConfig, loadConfig, getDefaultConfig, VoiceAgentKitConfigSchema } from '@reaatech/voice-agent-core';
 
const config = defineConfig({
  mcp: {
    endpoint: 'https://my-agent.example.com/mcp',
    timeout: 400,
  },
  stt: {
    provider: 'deepgram',
    model: 'nova-2',
    language: 'en',
    sampleRate: 8000,
  },
  tts: {
    provider: 'deepgram',
    voice: 'asteria',
    model: 'aura',
  },
  latency: {
    total: { target: 800, hardCap: 1200 },
    stages: { stt: 200, mcp: 400, tts: 200 },
  },
  session: {
    ttl: 3600,
    history: { maxTurns: 20, maxTokens: 4000 },
  },
  bargeIn: {
    enabled: true,
    minSpeechDuration: 300,
    confidenceThreshold: 0.7,
    silenceThreshold: 0.3,
  },
});

import { initializeObservability, getObservability, shutdownObservability } from '@reaatech/voice-agent-core';
 
await initializeObservability({
  serviceName: 'voice-agent-kit',
  serviceVersion: '1.0.0',
  enabled: true,
  otlpEndpoint: 'http://localhost:4318/v1/traces',
});
 
const obs = getObservability();
const span = obs.startSpan('voice.stt', { sessionId, provider: 'deepgram' });

import type { Transport, TransportConfig, TransportSessionMetadata } from '@reaatech/voice-agent-core';

import { createVADProvider, EnergyVADProvider, SemanticEndpointDetector } from '@reaatech/voice-agent-core';
 
const vad = createVADProvider({ provider: 'energy', silenceTimeoutMs: 500 });

import { createRecordingManager } from '@reaatech/voice-agent-core';
 
const recording = createRecordingManager({
  enabled: true,
  storage: 'filesystem',
  directory: './recordings',
  saveAudio: true,
  saveTranscript: true,
});

import { createCostTracker } from '@reaatech/voice-agent-core';
 
const cost = createCostTracker({
  enabled: true,
  currency: 'USD',
  providers: {
    deepgram: { stt: { pricePerMinute: 0.0059 }, tts: { pricePerCharacter: 0.000015 } },
  },
});
 
cost.trackSTTUsage(sessionId, turnId, audioDurationMs);
cost.trackTTSUsage(sessionId, turnId, characterCount);
const sessionCost = cost.getSessionCost(sessionId);

import {
  MockSTTProvider,
  MockTTSProvider,
  MockMCPClient,
  createMockSTTProvider,
  createMockTTSProvider,
  createMockMCPClient,
} from '@reaatech/voice-agent-core';