Auto-repair call intake agent for service advisors

Automate inbound 'how much to fix X' calls so advisors stay in the bay.

voice-agent automotive-service call-intake nextjs fastify deepgram elevenlabs openai langfuse twilio

The problem

Service advisors at independent auto-repair shops are constantly interrupted by phone calls from customers asking for price estimates on common repairs. Each call pulls them away from the shop floor, slowing down bay turnover and frustrating mechanics. Missed or delayed callbacks lead to lost jobs and lower conversion rates. Advisors need a way to handle initial triage without leaving their current task.

Built from

Intro

Service advisors at independent auto-repair shops spend a significant portion of their day on the phone answering “how much to fix X” calls. Each call pulls them off the shop floor, slows down bay turnover, and leads to missed or delayed callbacks that cost jobs. This recipe builds a voice agent that handles the initial triage — listening to the customer’s description, identifying the repair type, providing a ballpark estimate, and escalating to a human advisor when the request is too complex. You’ll wire six REAA packages into a Next.js dashboard backed by a Fastify WebSocket server, with Deepgram for speech-to-text, ElevenLabs for text-to-speech, OpenAI for LLM-based repair assessment, and Langfuse for observability and cost tracking.

Prerequisites

Node.js >= 22 and pnpm 10.x installed
Twilio account — a phone number with voice capabilities, your Account SID, and Auth Token
Deepgram API key for speech-to-text
ElevenLabs API key for text-to-speech (note the default voice ID used in this recipe)
OpenAI API key for LLM-based repair assessment
Langfuse account — host URL plus public and secret keys for observability tracing
Familiarity with TypeScript, Next.js App Router patterns, and basic WebSocket concepts

Step 1: Set up environment variables

The project scaffold is already on disk — package.json, tsconfig.json, vitest.config.ts, next.config.ts, and the app/ shell are in place. Start by inspecting the environment file and adding your real credentials.

Open .env.example — it lists every variable the system reads:

Example artifact

A complete, working implementation of this recipe — downloadable as a zip or browsable file by file. Generated by our build pipeline; tested with full coverage before publishing.

Download example (zip)Browse files

178 kB·119 tests·100.0% coverage·vitest passing

SHA-2560d100f8c9e85d99624a1c9b0d759e34b42d4300ec9c1497b3c289256eef8bed9

Book a conversation All solutions

Comments

Loading comments…

Intro

Prerequisites

Node.js >= 22 and pnpm 10.x installed

Twilio account — a phone number with voice capabilities, your Account SID, and Auth Token

Deepgram API key for speech-to-text

ElevenLabs API key for text-to-speech (note the default voice ID used in this recipe)

OpenAI API key for LLM-based repair assessment

Langfuse account — host URL plus public and secret keys for observability tracing

Familiarity with TypeScript, Next.js App Router patterns, and basic WebSocket concepts

import { z } from "zod"; import { ConfigurationError } from "@reaatech/agent-handoff"; import type { AppConfig } from "./types.js"; const AppConfigSchema = z.object({ server: z.object({ port: z.coerce.number().int().positive().default(3001), }), twilio: z.object({ accountSid: z.string().min(1, "TWILIO_ACCOUNT_SID is required"), authToken: z.string().min(1, "TWILIO_AUTH_TOKEN is required"), phoneNumber: z.string().min(1, "TWILIO_PHONE_NUMBER is required"), }), deepgram: z.object({ apiKey: z.string().min(1, "DEEPGRAM_API_KEY is required"), }), elevenlabs: z.object({ apiKey: z.string().min(1, "ELEVENLABS_API_KEY is required"), }), openai: z.object({ apiKey: z.string().min(1, "OPENAI_API_KEY is required"), }), langfuse: z.object({ secretKey: z.string().min(1, "LANGFUSE_SECRET_KEY is required"), publicKey: z.string().min(1, "LANGFUSE_PUBLIC_KEY is required"), baseUrl: z.string().min(1, "LANGFUSE_BASE_URL is required"), }), session: z.object({ ttl: z.coerce.number().int().positive().default(3600), }), latency: z.object({ target: z.coerce.number().int().positive().default(800), hardCap: z.coerce.number().int().positive().default(1200), }), }); export function loadConfig(): AppConfig { const env = { SERVER_PORT: process.env.SERVER_PORT, TWILIO_ACCOUNT_SID: process.env.TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN: process.env.TWILIO_AUTH_TOKEN, TWILIO_PHONE_NUMBER: process.env.TWILIO_PHONE_NUMBER, DEEPGRAM_API_KEY: process.env.DEEPGRAM_API_KEY, ELEVENLABS_API_KEY: process.env.ELEVENLABS_API_KEY, OPENAI_API_KEY: process.env.OPENAI_API_KEY, LANGFUSE_SECRET_KEY: process.env.LANGFUSE_SECRET_KEY, LANGFUSE_PUBLIC_KEY: process.env.LANGFUSE_PUBLIC_KEY, LANGFUSE_BASE_URL: process.env.LANGFUSE_BASE_URL, SESSION_TTL_SECONDS: process.env.SESSION_TTL_SECONDS, LATENCY_TARGET_MS: process.env.LATENCY_TARGET_MS, LATENCY_HARD_CAP_MS: process.env.LATENCY_HARD_CAP_MS, }; const parsed = AppConfigSchema.safeParse({ server: { port: env.SERVER_PORT }, twilio: { accountSid: env.TWILIO_ACCOUNT_SID, authToken: env.TWILIO_AUTH_TOKEN, phoneNumber: env.TWILIO_PHONE_NUMBER, }, deepgram: { apiKey: env.DEEPGRAM_API_KEY }, elevenlabs: { apiKey: env.ELEVENLABS_API_KEY }, openai: { apiKey: env.OPENAI_API_KEY }, langfuse: { secretKey: env.LANGFUSE_SECRET_KEY, publicKey: env.LANGFUSE_PUBLIC_KEY, baseUrl: env.LANGFUSE_BASE_URL, }, session: { ttl: env.SESSION_TTL_SECONDS }, latency: { target: env.LATENCY_TARGET_MS, hardCap: env.LATENCY_HARD_CAP_MS, }, }); if (!parsed.success) { const firstIssue = parsed.error.issues[0]; throw new ConfigurationError( `Config validation failed: ${firstIssue.message}`, ); } return parsed.data; } export const config: AppConfig = loadConfig();

import { createTTSProvider, TTSProviderInterface } from "@reaatech/voice-agent-tts"; import type { AudioChunk } from "@reaatech/voice-agent-core"; import type { AppConfig } from "../types.js"; const ELEVENLABS_CONFIG = { provider: 'elevenlabs' as const, modelId: 'eleven_flash_v2_5', voiceId: 'JBFqnCBsd6RMkjVDRZzb', outputFormat: 'mulaw_8000', }; export class TextToSpeechService { private provider: ReturnType<typeof createTTSProvider>; readonly name = 'elevenlabs'; readonly supportsStreaming = true; readonly firstByteLatencyMs: number | null = null; constructor(config: AppConfig) { this.provider = createTTSProvider({ provider: 'elevenlabs', config: { ...ELEVENLABS_CONFIG, apiKey: config.elevenlabs.apiKey, }, }); } async *speak(text: string): AsyncIterable<AudioChunk> { if (!text) return; const sentences = TTSProviderInterface.chunkTextForStreaming(text, 200); for (let i = 0; i < sentences.length; i++) { const sentence = sentences[i]; if (!sentence) continue; try { for await (const rawChunk of this.provider.synthesize(sentence, { ...ELEVENLABS_CONFIG, apiKey: '', })) { const formatted = TTSProviderInterface.formatAudioForTwilio(rawChunk); yield formatted; } } catch (err) { console.error('TTS synthesis error:', err); try { for await (const fallbackChunk of this.provider.synthesize( `I'm sorry, I didn't quite catch that.`, { ...ELEVENLABS_CONFIG, apiKey: '' }, )) { const formatted = TTSProviderInterface.formatAudioForTwilio(fallbackChunk); yield formatted; } } catch { const silence = TTSProviderInterface.createSilenceChunk(300); yield silence; } } if (i < sentences.length - 1) { const gap = TTSProviderInterface.createSilenceChunk(300); yield gap; } } } cancel(): void { this.provider.cancel(); } }

import { generateText, Output } from "ai"; import { openai } from "@ai-sdk/openai"; import { z } from "zod"; import type { CustomerInfo, RepairAssessment } from "../types.js"; import { EscalationRouter } from "../handoff/escalation-router.js"; const escalationRouter = new EscalationRouter(); const AUTO_REPAIR_INTENTS = [ 'oil_change', 'brake_service', 'tire_service', 'engine_repair', 'transmission', 'ac_service', 'battery', 'general', ] as const; export const RepairAssessmentSchema = z.object({ intent: z.enum(AUTO_REPAIR_INTENTS), confidence: z.number().min(0).max(1), estimatedCostLow: z.number(), estimatedCostHigh: z.number(), partsCostEstimate: z.number(), laborCostEstimate: z.number(), estimatedTimeMinutes: z.number(), followUpQuestions: z.array(z.string()), needsHumanHandoff: z.boolean(), }); export const AUTO_REPAIR_SYSTEM_PROMPT = `You are an expert auto repair service advisor. Your job is to assess customer repair needs and provide estimates. Return a JSON object matching the schema. Set needsHumanHandoff to true if the issue is complex or you're unsure. Pricing ranges (parts + labor): - Oil change: $30-80 - Brake service: $150-300 per axle - Tire service: $100-300 each - Engine repair: $500-2000 - Transmission: $1500-4000 - AC service: $150-500 - Battery: $100-250 - General service: $50-500 Estimate within these bands based on the customer's description. If the customer's issue is complex, set needsHumanHandoff to true.`; export const FOLLOW_UP_SYSTEM_PROMPT = `You are a friendly auto repair service advisor. Respond to the customer's question based on the repair assessment. Be concise, helpful, and professional. Keep responses under 2 sentences when possible.`; export async function generateRepairAssessment( transcript: string, customerInfo: CustomerInfo, ): Promise<RepairAssessment> { const result = await generateText({ model: openai("gpt-4o"), output: Output.object({ schema: RepairAssessmentSchema }), system: AUTO_REPAIR_SYSTEM_PROMPT, prompt: `Customer vehicle: ${customerInfo.vehicleMake ?? 'unknown'} ${customerInfo.vehicleModel ?? ''} ${customerInfo.vehicleYear !== undefined ? String(customerInfo.vehicleYear) : ''} Customer concern: ${transcript}`, }); if (result.output.needsHumanHandoff) { await escalationRouter.evaluateEscalation(result.output, transcript); } return result.output; } export async function generateFollowUpResponse( history: Array<{ role: 'user' | 'assistant'; content: string }>, assessment: RepairAssessment, ): Promise<string> { const result = await generateText({ model: openai("gpt-4o"), system: FOLLOW_UP_SYSTEM_PROMPT, messages: [ { role: 'system', content: `Current assessment: ${assessment.intent} repair, estimated $${String(assessment.estimatedCostLow)}-$${String(assessment.estimatedCostHigh)}`, }, ...history, ], }); return result.text; }

import { SessionManager, initializeSessionManager, Turn, } from "@reaatech/voice-agent-core"; import type { CallSessionRecord, CustomerInfo } from "../types.js"; export class CallSessionStore { private sessionManager: SessionManager; private records: Map<string, CallSessionRecord> = new Map(); private callSidIndex: Map<string, string> = new Map(); constructor(ttl: number) { this.sessionManager = initializeSessionManager({ defaultTTL: ttl, maxTurns: 20, maxTokens: 4000, }); } create(callSid: string, metadata: CustomerInfo): CallSessionRecord { const session = this.sessionManager.createSession({ callSid, mcpEndpoint: 'internal://repair-advisor', sttProvider: 'deepgram', ttsProvider: 'elevenlabs', metadata, }); const record: CallSessionRecord = { sessionId: session.sessionId, callSid, customer: metadata, intent: null, estimate: null, startTime: new Date(), status: 'in_progress', }; this.records.set(session.sessionId, record); this.callSidIndex.set(callSid, session.sessionId); return record; } get(sessionId: string): CallSessionRecord | undefined { return this.records.get(sessionId); } getByCallSid(callSid: string): CallSessionRecord | undefined { const sessionId = this.callSidIndex.get(callSid); if (!sessionId) return undefined; return this.records.get(sessionId); } addTurn(sessionId: string, turn: Omit<Turn, 'turnId'>): void { this.sessionManager.addTurn(sessionId, turn); } getHistory(sessionId: string, maxTurns?: number): Turn[] { return this.sessionManager.getConversationHistory(sessionId, maxTurns); } close(sessionId: string): void { const record = this.records.get(sessionId); if (record) { record.status = 'completed'; this.callSidIndex.delete(record.callSid); } this.sessionManager.closeSession(sessionId); } getActiveCallCount(): number { return this.sessionManager.getActiveSessionCount(); } getAllActiveRecords(): CallSessionRecord[] { const result: CallSessionRecord[] = []; for (const record of this.records.values()) { if (record.status === 'in_progress') { result.push(record); } } return result; } }

import { Langfuse } from "langfuse"; import { createCostTracker } from "@reaatech/voice-agent-core"; import type { AppConfig } from "../types.js"; export class ObservabilityService { private langfuse: Langfuse; private costTracker: ReturnType<typeof createCostTracker>; constructor(config: AppConfig) { this.langfuse = new Langfuse({ secretKey: config.langfuse.secretKey, publicKey: config.langfuse.publicKey, baseUrl: config.langfuse.baseUrl, }); this.costTracker = createCostTracker({ enabled: true, currency: 'USD', providers: { deepgram: { stt: { pricePerMinute: 0.0059 } }, elevenlabs: { tts: { pricePerCharacter: 0.000015 } }, openai: { llm: { pricePerInputToken: 0.00001, pricePerOutputToken: 0.00003 } }, }, }); } traceCall(sessionId: string, callSid: string): void { this.langfuse.trace({ name: callSid, sessionId }); } logTurn( sessionId: string, metrics: { sttLatencyMs?: number; mcpLatencyMs?: number; ttsLatencyMs?: number; totalLatencyMs?: number }, ): void { this.langfuse.trace({ name: `turn-${sessionId}`, sessionId, input: metrics, }); } logCost(sessionId: string, cost: { totalCost: number }): void { this.langfuse.trace({ name: `cost-${sessionId}`, sessionId, input: cost, }); } logEscalation(sessionId: string, reason: string): void { this.langfuse.trace({ name: `escalation-${sessionId}`, sessionId, input: { reason }, }); } finalizeTrace(): void { this.langfuse.flush(); } trackSTTUsage(sessionId: string, turnId: string, durationMs: number): void { this.costTracker.trackSTTUsage(sessionId, turnId, durationMs); } trackTTSUsage(sessionId: string, turnId: string, charCount: number): void { this.costTracker.trackTTSUsage(sessionId, turnId, charCount); } getSessionCost(sessionId: string) { return this.costTracker.getSessionCost(sessionId); } async shutdown(): Promise<void> { await this.langfuse.shutdownAsync(); } } let _observabilityService: ObservabilityService | undefined; export function initObservability(config?: AppConfig): ObservabilityService { if (!_observabilityService) { if (!config) { throw new Error('Config required for first initialization'); } _observabilityService = new ObservabilityService(config); } return _observabilityService; } export function getObservabilityService(): ObservabilityService { if (!_observabilityService) { throw new Error('Observability not initialized'); } return _observabilityService; }

Auto-repair call intake agent for service advisors

The problem

Built from

Intro

Prerequisites

Step 1: Set up environment variables

Example artifact

Comments

Intro

Prerequisites

Step 1: Set up environment variables

Step 2: Define types and configuration

Step 3: Build the pricing database

Step 4: Create the STT and TTS adapters

Step 5: Wire Twilio telephony

Step 6: Build the LLM repair advisor

Step 7: Create the escalation router

Step 8: Implement the session store

Step 9: Set up observability and cost tracking

Step 10: Wire the voice pipeline

Step 11: Create the Next.js API routes and instrumentation

Step 12: Bootstrap the Fastify WebSocket server

Step 13: Run the tests

Next steps