@absolutejs/voice 0.0.22-beta.542 → 0.0.22-beta.543

package/dist/core/cachedTTS.d.ts

@@ -0,0 +1,30 @@
+import type { TTSAdapter, TTSAdapterOpenOptions } from './types';
+export type CachedTTSOptions = {
+    /**
+     * Return a stable cache key for an utterance whose synthesized audio should
+     * be rendered once and replayed verbatim on later calls (typically a
+     * greeting / fixed prompt), or `null`/`undefined` to synthesize it live every
+     * time (dynamic turn replies).
+     *
+     * The key must encode everything that affects the audio — the text, the
+     * voice, the model, and the output format. Because the cache is
+     * content-addressed, editing any of those naturally produces a new key, so a
+     * stale rendering is never replayed: the first call after a change re-renders
+     * (and re-caches) while the old entry is simply orphaned.
+     */
+    keyFor: (text: string, openOptions: TTSAdapterOpenOptions) => string | null | undefined;
+    /** Max distinct utterances to retain (LRU by insertion). Default 32. */
+    maxEntries?: number;
+};
+/**
+ * Wrap a TTS adapter so selected utterances are synthesized once and replayed
+ * from memory on subsequent `send()`s — eliminating provider latency for fixed
+ * prompts like a call greeting. Utterances are selected (and keyed) by
+ * `options.keyFor`; everything else passes straight through to the inner
+ * adapter, so dynamic replies are unaffected.
+ *
+ * The cache lives for the lifetime of the wrapper (one per adapter), so it is
+ * shared across every session/call the adapter serves. Warm it ahead of the
+ * first call by opening a session and `send()`ing the cacheable text once.
+ */
+export declare const createCachedTTS: (inner: TTSAdapter, options: CachedTTSOptions) => TTSAdapter<TTSAdapterOpenOptions>;

package/dist/index.d.ts

@@ -159,6 +159,7 @@ export { computePcmDurationMs, createVoiceMemoryRecordingStore, createVoiceWavRe
 export type { EncodeStereoWavInput, InterleavePcmInput, StoredVoiceRecordingArtifact, VoiceRecordingArtifact, VoiceRecordingChannel, VoiceRecordingEncoder, VoiceRecordingEncoderInput, VoiceRecordingEncoderResult, VoiceRecordingStore, } from "./core/recordingStore";
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace, } from "./core/assistantMemory";
 export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel, createVoiceProviderOrchestrationProfile, resolveVoiceProviderRoutingPolicyPreset, createVoiceProviderRouter, } from "./core/modelAdapters";
+export { createCachedTTS } from "./core/cachedTTS";
 export { createOpenAIVoiceTTS } from "./core/openaiTTS";
 export { createVoiceProviderHealthHTMLHandler, createVoiceProviderHealthJSONHandler, createVoiceProviderHealthRoutes, renderVoiceProviderHealthHTML, summarizeVoiceProviderHealth, } from "./core/providerHealth";
 export { createVoiceProviderCapabilityHTMLHandler, createVoiceProviderCapabilityJSONHandler, createVoiceProviderCapabilityRoutes, renderVoiceProviderCapabilityHTML, summarizeVoiceProviderCapabilities, } from "./core/providerCapabilities";
@@ -220,6 +221,7 @@ export type { VoiceSimulationSuiteAssertionInput, VoiceSimulationSuiteAssertionR
 export type { VoiceWorkflowContract, VoiceWorkflowContractDefinition, VoiceWorkflowContractField, VoiceWorkflowContractFieldMatch, VoiceWorkflowContractPresetName, VoiceWorkflowContractPresetOptions, VoiceWorkflowContractTracePayload, VoiceWorkflowContractValidation, VoiceWorkflowContractValidationIssue, VoiceWorkflowOutcome, } from "./core/workflowContract";
 export type { VoiceSessionListHTMLHandlerOptions, VoiceSessionListItem, VoiceSessionListOptions, VoiceSessionListRoutesOptions, VoiceSessionListStatus, VoiceProviderFallbackRecoverySummary, VoiceSessionReplay, VoiceSessionReplayHTMLHandlerOptions, VoiceSessionReplayOptions, VoiceSessionReplayRoutesOptions, VoiceSessionReplayTurn, } from "./core/sessionReplay";
 export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderOrchestrationProfile, VoiceProviderOrchestrationProfileOptions, VoiceProviderOrchestrationResolvedSurface, VoiceProviderOrchestrationSurface, VoiceProviderRouterPolicy, VoiceProviderRouterPolicyPreset, VoiceProviderRouterPolicyWeights, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceProviderRouterStrategy, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions, } from "./core/modelAdapters";
+export type { CachedTTSOptions } from "./core/cachedTTS";
 export type { OpenAIVoiceTTSOptions, OpenAIVoiceTTSVoice, } from "./core/openaiTTS";
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions, } from "./core/providerHealth";
 export type { VoiceProviderCapabilityDefinition, VoiceProviderCapabilityHandlerOptions, VoiceProviderCapabilityHTMLHandlerOptions, VoiceProviderCapabilityKind, VoiceProviderCapabilityOptions, VoiceProviderCapabilityReport, VoiceProviderCapabilityRoutesOptions, VoiceProviderCapabilitySummary, } from "./core/providerCapabilities";

package/dist/index.js

@@ -44998,6 +44998,74 @@ var createGeminiVoiceAssistantModel = (options) => {
     }
   };
 };
+// src/core/cachedTTS.ts
+var DEFAULT_MAX_ENTRIES = 32;
+var createCachedTTS = (inner, options) => {
+  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const cache = new Map;
+  const remember = (key, events) => {
+    cache.delete(key);
+    cache.set(key, events);
+    while (cache.size > maxEntries) {
+      const oldest = cache.keys().next().value;
+      if (oldest === undefined) {
+        break;
+      }
+      cache.delete(oldest);
+    }
+  };
+  return {
+    kind: "tts",
+    open: async (openOptions) => {
+      const session = await inner.open(openOptions);
+      const audioHandlers = new Set;
+      let capture = null;
+      session.on("audio", (event) => {
+        if (capture) {
+          capture.push(event);
+        }
+      });
+      return {
+        cancel: async (reason) => {
+          if (session.cancel) {
+            await session.cancel(reason);
+          }
+        },
+        close: (reason) => session.close(reason),
+        on: (event, handler) => {
+          if (event === "audio") {
+            audioHandlers.add(handler);
+          }
+          return session.on(event, handler);
+        },
+        send: async (text) => {
+          const key = options.keyFor(text, openOptions);
+          if (key === null || key === undefined) {
+            await session.send(text);
+            return;
+          }
+          const cached = cache.get(key);
+          if (cached) {
+            for (const event of cached) {
+              const replay = {
+                ...event,
+                receivedAt: Date.now()
+              };
+              for (const handler of audioHandlers) {
+                await Promise.resolve(handler(replay));
+              }
+            }
+            return;
+          }
+          capture = [];
+          await session.send(text);
+          remember(key, capture);
+          capture = null;
+        }
+      };
+    }
+  };
+};
 // src/core/openaiTTS.ts
 var OPENAI_PCM24_FORMAT = {
   channels: 1,
@@ -52371,6 +52439,7 @@ export {
   createDomainPhraseHints,
   createDomainLexicon,
   createCoturnIceServers,
+  createCachedTTS,
   createAnthropicVoiceAssistantModel,
   createAIVoiceModel,
   conditionAudioChunk,

package/package.json

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