@absolutejs/voice 0.0.22-beta.479 → 0.0.22-beta.480

package/dist/aiVoiceModel.d.ts

@@ -1,9 +1,14 @@
-import type { AIProviderConfig } from "@absolutejs/ai";
+import type { AIProviderConfig, AIUsage } from "@absolutejs/ai";
 import type { VoiceAgentModel } from "./agent";
 import type { VoiceSessionRecord } from "./types";
 export type CreateAIVoiceModelOptions = {
     model: string;
+    onUsage?: (usage: AIUsage & {
+        model: string;
+        provider?: string;
+    }) => void;
     provider: AIProviderConfig;
+    providerName?: string;
     signal?: AbortSignal;
     systemPrompt?: string;
 };

package/dist/costAccounting.d.ts

@@ -0,0 +1,76 @@
+export type VoiceProviderRates = {
+    llm?: {
+        cachedInputPerMillionTokensUsd?: number;
+        inputPerMillionTokensUsd: number;
+        outputPerMillionTokensUsd: number;
+    };
+    stt?: {
+        perSecondUsd: number;
+    };
+    telephony?: {
+        perMinuteUsd: number;
+    };
+    tts?: {
+        perMillionCharactersUsd?: number;
+        perSecondUsd?: number;
+    };
+};
+export type VoicePriceBook = Record<string, VoiceProviderRates>;
+export declare const DEFAULT_VOICE_PRICE_BOOK: VoicePriceBook;
+export type VoiceCostLLMRecord = {
+    cachedInputTokens?: number;
+    inputTokens?: number;
+    model?: string;
+    outputTokens?: number;
+    provider?: string;
+};
+export type VoiceCostTTSRecord = {
+    audioMs?: number;
+    characters?: number;
+    provider?: string;
+    voice?: string;
+};
+export type VoiceCostSTTRecord = {
+    audioMs: number;
+    model?: string;
+    provider?: string;
+};
+export type VoiceCostTelephonyRecord = {
+    minutes: number;
+    provider?: string;
+};
+export type VoiceCostBreakdown = {
+    llm: {
+        cachedInputTokens: number;
+        inputTokens: number;
+        outputTokens: number;
+        usd: number;
+    };
+    sessionId?: string;
+    stt: {
+        audioMs: number;
+        usd: number;
+    };
+    telephony: {
+        minutes: number;
+        usd: number;
+    };
+    totalUsd: number;
+    tts: {
+        audioMs: number;
+        characters: number;
+        usd: number;
+    };
+};
+export type VoiceCostAccountant = {
+    recordLLM: (usage: VoiceCostLLMRecord) => void;
+    recordSTT: (input: VoiceCostSTTRecord) => void;
+    recordTTS: (input: VoiceCostTTSRecord) => void;
+    recordTelephony: (input: VoiceCostTelephonyRecord) => void;
+    snapshot: () => VoiceCostBreakdown;
+};
+export type CreateVoiceCostAccountantOptions = {
+    priceBook?: VoicePriceBook;
+    sessionId?: string;
+};
+export declare const createVoiceCostAccountant: (options?: CreateVoiceCostAccountantOptions) => VoiceCostAccountant;

package/dist/index.d.ts

@@ -71,6 +71,8 @@ export { createVoiceSessionListRoutes, createVoiceSessionReplayHTMLHandler, crea
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool, } from "./agent";
 export { createAIVoiceModel } from "./aiVoiceModel";
 export type { CreateAIVoiceModelOptions } from "./aiVoiceModel";
+export { DEFAULT_VOICE_PRICE_BOOK, createVoiceCostAccountant, } from "./costAccounting";
+export type { CreateVoiceCostAccountantOptions, VoiceCostAccountant, VoiceCostBreakdown, VoiceCostLLMRecord, VoiceCostSTTRecord, VoiceCostTTSRecord, VoiceCostTelephonyRecord, VoicePriceBook, VoiceProviderRates, } from "./costAccounting";
 export { createMonologueAMDDetector } from "./amdDetector";
 export type { MonologueAMDDetectorOptions, VoiceAMDDetector, VoiceAMDDetectorInput, VoiceAMDVerdict, } from "./amdDetector";
 export { createVoiceRAGTool } from "./ragTool";

package/dist/index.js

@@ -4030,6 +4030,31 @@ var createVoiceSession = (options) => {
       }
     }
   };
+  const finalizeCostReport = async (session) => {
+    if (!options.costAccountant) {
+      return;
+    }
+    const lifecycle = session.call;
+    if (lifecycle?.startedAt && lifecycle.endedAt) {
+      const durationMs = Math.max(0, lifecycle.endedAt - lifecycle.startedAt);
+      const minutes = durationMs / 60000;
+      if (minutes > 0) {
+        options.costAccountant.recordTelephony({
+          minutes,
+          provider: options.costTelephony?.provider
+        });
+      }
+    }
+    const breakdown = options.costAccountant.snapshot();
+    await appendTrace({
+      payload: {
+        ...breakdown,
+        sessionId: options.id
+      },
+      session,
+      type: "cost.ready"
+    });
+  };
   const cancelActiveTTS = async (reason) => {
     const activeSession = ttsSession;
     const cancelledTurnId = activeTTSTurnId;
@@ -4977,6 +5002,11 @@ var createVoiceSession = (options) => {
             turnId: turn.id
           });
           await activeTTSSession.send(output.assistantText);
+          if (options.costAccountant) {
+            options.costAccountant.recordTTS({
+              characters: output.assistantText.length
+            });
+          }
           await appendTurnLatencyStage({
             session,
             stage: "tts_send_completed",
@@ -5145,6 +5175,11 @@ var createVoiceSession = (options) => {
       primaryAudioMs: getBufferedAudioDurationMs(currentTurnAudio.map((audio) => audio.chunk)),
       primaryPassCostUnit: options.costTelemetry?.primaryPassCostUnit
     });
+    if (options.costAccountant && costEstimate.totalBillableAudioMs > 0) {
+      options.costAccountant.recordSTT({
+        audioMs: costEstimate.totalBillableAudioMs
+      });
+    }
     const turn = {
       committedAt: Date.now(),
       id: createId(),
@@ -5416,6 +5451,7 @@ var createVoiceSession = (options) => {
     await closeTTSSession(reason);
     await closeAdapter(reason);
     await persistRecordings();
+    await finalizeCostReport(session);
     await Promise.resolve(socket.close(1000, reason));
     if (session.call?.endedAt && session.call.disposition === disposition) {
       await appendTrace({
@@ -34924,6 +34960,12 @@ var createAIVoiceModel = (options) => ({
           id: chunk.id,
           name: chunk.name
         });
+      } else if (chunk.type === "done" && chunk.usage && options.onUsage) {
+        options.onUsage({
+          ...chunk.usage,
+          model: options.model,
+          provider: options.providerName
+        });
       }
     }
     const output = {
@@ -34935,6 +34977,149 @@ var createAIVoiceModel = (options) => ({
     return output;
   }
 });
+// src/costAccounting.ts
+var DEFAULT_VOICE_PRICE_BOOK = {
+  "anthropic:claude-opus-4-5": {
+    llm: {
+      cachedInputPerMillionTokensUsd: 1.5,
+      inputPerMillionTokensUsd: 15,
+      outputPerMillionTokensUsd: 75
+    }
+  },
+  "anthropic:claude-sonnet-4-5": {
+    llm: {
+      cachedInputPerMillionTokensUsd: 0.3,
+      inputPerMillionTokensUsd: 3,
+      outputPerMillionTokensUsd: 15
+    }
+  },
+  "assemblyai:streaming": { stt: { perSecondUsd: 0.00018 } },
+  "azure:tts-neural": { tts: { perMillionCharactersUsd: 16 } },
+  "cartesia:sonic-2": { tts: { perMillionCharactersUsd: 65 } },
+  "deepgram:nova-3": { stt: { perSecondUsd: 0.000077 } },
+  "elevenlabs:flash-v2-5": { tts: { perMillionCharactersUsd: 50 } },
+  "openai:gpt-4o-mini": {
+    llm: {
+      cachedInputPerMillionTokensUsd: 0.075,
+      inputPerMillionTokensUsd: 0.15,
+      outputPerMillionTokensUsd: 0.6
+    }
+  },
+  "openai:gpt-4o-realtime": {
+    llm: {
+      cachedInputPerMillionTokensUsd: 2.5,
+      inputPerMillionTokensUsd: 5,
+      outputPerMillionTokensUsd: 20
+    }
+  },
+  "openai:whisper-1": { stt: { perSecondUsd: 0.0001 } },
+  telnyx: { telephony: { perMinuteUsd: 0.007 } },
+  twilio: { telephony: { perMinuteUsd: 0.014 } }
+};
+var resolveProviderKey = (provider, model) => {
+  if (provider && model) {
+    return `${provider.toLowerCase()}:${model.toLowerCase()}`;
+  }
+  if (provider) {
+    return provider.toLowerCase();
+  }
+  return;
+};
+var lookupRates = (priceBook, provider, model) => {
+  const exactKey = resolveProviderKey(provider, model);
+  if (exactKey && priceBook[exactKey]) {
+    return priceBook[exactKey];
+  }
+  const providerKey = provider?.toLowerCase();
+  if (providerKey && priceBook[providerKey]) {
+    return priceBook[providerKey];
+  }
+  return;
+};
+var createVoiceCostAccountant = (options = {}) => {
+  const priceBook = options.priceBook ?? DEFAULT_VOICE_PRICE_BOOK;
+  let llmInput = 0;
+  let llmCachedInput = 0;
+  let llmOutput = 0;
+  let llmUsd = 0;
+  let ttsCharacters = 0;
+  let ttsAudioMs = 0;
+  let ttsUsd = 0;
+  let sttAudioMs = 0;
+  let sttUsd = 0;
+  let telephonyMinutes = 0;
+  let telephonyUsd = 0;
+  return {
+    recordLLM: (usage) => {
+      const input = usage.inputTokens ?? 0;
+      const cached = usage.cachedInputTokens ?? 0;
+      const output = usage.outputTokens ?? 0;
+      llmInput += input;
+      llmCachedInput += cached;
+      llmOutput += output;
+      const rates = lookupRates(priceBook, usage.provider, usage.model)?.llm;
+      if (!rates) {
+        return;
+      }
+      const cachedRate = rates.cachedInputPerMillionTokensUsd ?? rates.inputPerMillionTokensUsd;
+      llmUsd += Math.max(0, input - cached) * rates.inputPerMillionTokensUsd / 1e6 + cached * cachedRate / 1e6 + output * rates.outputPerMillionTokensUsd / 1e6;
+    },
+    recordSTT: (input) => {
+      sttAudioMs += Math.max(0, input.audioMs);
+      const rates = lookupRates(priceBook, input.provider, input.model)?.stt;
+      if (!rates) {
+        return;
+      }
+      sttUsd += Math.max(0, input.audioMs) / 1000 * rates.perSecondUsd;
+    },
+    recordTTS: (input) => {
+      const chars = input.characters ?? 0;
+      const audioMs = input.audioMs ?? 0;
+      ttsCharacters += chars;
+      ttsAudioMs += audioMs;
+      const rates = lookupRates(priceBook, input.provider, input.voice)?.tts;
+      if (!rates) {
+        return;
+      }
+      if (rates.perMillionCharactersUsd !== undefined && chars > 0) {
+        ttsUsd += chars * rates.perMillionCharactersUsd / 1e6;
+      } else if (rates.perSecondUsd !== undefined && audioMs > 0) {
+        ttsUsd += audioMs / 1000 * rates.perSecondUsd;
+      }
+    },
+    recordTelephony: (input) => {
+      telephonyMinutes += Math.max(0, input.minutes);
+      const rates = lookupRates(priceBook, input.provider)?.telephony;
+      if (!rates) {
+        return;
+      }
+      telephonyUsd += Math.max(0, input.minutes) * rates.perMinuteUsd;
+    },
+    snapshot: () => ({
+      llm: {
+        cachedInputTokens: llmCachedInput,
+        inputTokens: llmInput,
+        outputTokens: llmOutput,
+        usd: Math.round(llmUsd * 1e6) / 1e6
+      },
+      sessionId: options.sessionId,
+      stt: {
+        audioMs: sttAudioMs,
+        usd: Math.round(sttUsd * 1e6) / 1e6
+      },
+      telephony: {
+        minutes: telephonyMinutes,
+        usd: Math.round(telephonyUsd * 1e6) / 1e6
+      },
+      totalUsd: Math.round((llmUsd + ttsUsd + sttUsd + telephonyUsd) * 1e6) / 1e6,
+      tts: {
+        audioMs: ttsAudioMs,
+        characters: ttsCharacters,
+        usd: Math.round(ttsUsd * 1e6) / 1e6
+      }
+    })
+  };
+};
 // src/amdDetector.ts
 var createMonologueAMDDetector = (options = {}) => {
   const minMonologueMs = options.minMonologueMs ?? 8000;
@@ -46076,6 +46261,7 @@ export {
   createVoiceDeliveryRuntime,
   createVoiceDataControlRoutes,
   createVoiceDTMFTool,
+  createVoiceCostAccountant,
   createVoiceCompetitiveCoverageRoutes,
   createVoiceCampaignWorkerLoop,
   createVoiceCampaignWorker,
@@ -46290,5 +46476,6 @@ export {
   VOICE_LIVE_OPS_ACTIONS,
   TURN_PROFILE_DEFAULTS,
   DEFAULT_VOICE_PROOF_TREND_PROFILE_DEFINITIONS,
-  DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS
+  DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS,
+  DEFAULT_VOICE_PRICE_BOOK
 };

package/dist/testing/index.js

@@ -5998,6 +5998,31 @@ var createVoiceSession = (options) => {
       }
     }
   };
+  const finalizeCostReport = async (session) => {
+    if (!options.costAccountant) {
+      return;
+    }
+    const lifecycle = session.call;
+    if (lifecycle?.startedAt && lifecycle.endedAt) {
+      const durationMs = Math.max(0, lifecycle.endedAt - lifecycle.startedAt);
+      const minutes = durationMs / 60000;
+      if (minutes > 0) {
+        options.costAccountant.recordTelephony({
+          minutes,
+          provider: options.costTelephony?.provider
+        });
+      }
+    }
+    const breakdown = options.costAccountant.snapshot();
+    await appendTrace({
+      payload: {
+        ...breakdown,
+        sessionId: options.id
+      },
+      session,
+      type: "cost.ready"
+    });
+  };
   const cancelActiveTTS = async (reason) => {
     const activeSession = ttsSession;
     const cancelledTurnId = activeTTSTurnId;
@@ -6945,6 +6970,11 @@ var createVoiceSession = (options) => {
             turnId: turn.id
           });
           await activeTTSSession.send(output.assistantText);
+          if (options.costAccountant) {
+            options.costAccountant.recordTTS({
+              characters: output.assistantText.length
+            });
+          }
           await appendTurnLatencyStage({
             session,
             stage: "tts_send_completed",
@@ -7113,6 +7143,11 @@ var createVoiceSession = (options) => {
       primaryAudioMs: getBufferedAudioDurationMs(currentTurnAudio.map((audio) => audio.chunk)),
       primaryPassCostUnit: options.costTelemetry?.primaryPassCostUnit
     });
+    if (options.costAccountant && costEstimate.totalBillableAudioMs > 0) {
+      options.costAccountant.recordSTT({
+        audioMs: costEstimate.totalBillableAudioMs
+      });
+    }
     const turn = {
       committedAt: Date.now(),
       id: createId(),
@@ -7384,6 +7419,7 @@ var createVoiceSession = (options) => {
     await closeTTSSession(reason);
     await closeAdapter(reason);
     await persistRecordings();
+    await finalizeCostReport(session);
     await Promise.resolve(socket.close(1000, reason));
     if (session.call?.endedAt && session.call.disposition === disposition) {
       await appendTrace({

package/dist/trace.d.ts

@@ -1,5 +1,5 @@
 import type { S3Client, S3Options } from "bun";
-export type VoiceTraceEventType = "assistant.guardrail" | "assistant.memory" | "assistant.run" | "agent.context" | "agent.handoff" | "agent.model" | "agent.result" | "agent.tool" | "call.handoff" | "call.lifecycle" | "client.barge_in" | "client.browser_media" | "client.live_latency" | "client.reconnect" | "client.telephony_media" | "operator.action" | "provider.decision" | "recording.ready" | "session.error" | "turn.assistant" | "turn.committed" | "turn.cost" | "turn_latency.stage" | "turn.transcript" | "workflow.contract";
+export type VoiceTraceEventType = "assistant.guardrail" | "assistant.memory" | "assistant.run" | "agent.context" | "agent.handoff" | "agent.model" | "agent.result" | "agent.tool" | "call.handoff" | "call.lifecycle" | "client.barge_in" | "client.browser_media" | "client.live_latency" | "client.reconnect" | "client.telephony_media" | "cost.ready" | "operator.action" | "provider.decision" | "recording.ready" | "session.error" | "turn.assistant" | "turn.committed" | "turn.cost" | "turn_latency.stage" | "turn.transcript" | "workflow.contract";
 export type VoiceTraceEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
     at: number;
     id?: string;

package/dist/types.d.ts

@@ -726,6 +726,10 @@ export type CreateVoiceSessionOptions<TContext = unknown, TSession extends Voice
     recording?: VoiceSessionRecordingConfig;
     callSilenceTimeoutMs?: number;
     amd?: import("./amdDetector").VoiceAMDDetector<TContext, TSession, TResult>;
+    costAccountant?: import("./costAccounting").VoiceCostAccountant;
+    costTelephony?: {
+        provider?: string;
+    };
     reconnect: Required<VoiceReconnectConfig>;
     phraseHints?: VoicePhraseHint[];
     sessionMetadata?: Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/voice",
-  "version": "0.0.22-beta.479",
+  "version": "0.0.22-beta.480",
   "description": "Voice primitives and Elysia plugin for AbsoluteJS",
   "repository": {
     "type": "git",