sales-model 0.1.0__py3-none-any.whl

app/observability/logging.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import logging
+import os
+
+import structlog
+
+
+def configure_logging() -> None:
+    level_name = os.getenv("LOG_LEVEL", "INFO").upper()
+    level = logging._nameToLevel.get(level_name, logging.INFO)
+    logging.basicConfig(level=level, format="%(message)s")
+    structlog.configure(
+        processors=[
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.JSONRenderer(),
+        ],
+        wrapper_class=structlog.make_filtering_bound_logger(level),
+    )
+
+
+def get_logger(name: str = "voice") -> structlog.stdlib.BoundLogger:
+    return structlog.get_logger(name)

app/observability/metrics.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+
+def record_latency(_: str, __: float) -> None:
+    return
+
+
+def increment(_: str, __: int = 1) -> None:
+    return

app/observability/tracing.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+
+def start_span(_: str):
+    return None

app/providers/azure_foundry_stt.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import AsyncIterator, Optional
+
+import azure.cognitiveservices.speech as speechsdk
+
+from app.providers.stt_base import STTProvider, STTStream, TranscriptEvent
+
+
+def _speech_config() -> speechsdk.SpeechConfig:
+    key = os.getenv("SPEECH_KEY")
+    endpoint = os.getenv("ENDPOINT") or os.getenv("SPEECH_ENDPOINT")
+    region = os.getenv("SPEECH_REGION")
+
+    if not key or not (endpoint or region):
+        raise RuntimeError("Missing SPEECH_KEY and ENDPOINT or SPEECH_REGION for Foundry Speech.")
+
+    if endpoint:
+        config = speechsdk.SpeechConfig(subscription=key, endpoint=endpoint)
+    else:
+        config = speechsdk.SpeechConfig(subscription=key, region=region)
+
+    language = os.getenv("SPEECH_LANGUAGE", "en-US")
+    config.speech_recognition_language = language
+
+    end_silence = os.getenv("SPEECH_END_SILENCE_MS", "600")
+    initial_silence = os.getenv("SPEECH_INITIAL_SILENCE_MS", "4000")
+    stable_partial = os.getenv("SPEECH_STABLE_PARTIAL", "3")
+    segment_silence = os.getenv("SPEECH_SEGMENT_SILENCE_MS")
+
+    try:
+        config.set_property(speechsdk.PropertyId.SpeechServiceConnection_EndSilenceTimeoutMs, end_silence)
+        config.set_property(speechsdk.PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, initial_silence)
+        config.set_property(speechsdk.PropertyId.SpeechServiceResponse_StablePartialResultThreshold, stable_partial)
+        if segment_silence:
+            config.set_property(
+                speechsdk.PropertyId.SpeechServiceConnection_SegmentationSilenceTimeoutMs, segment_silence
+            )
+    except Exception:
+        # If a property isn't supported in this SDK version, ignore.
+        pass
+    return config
+
+
+class FoundrySTTStream(STTStream):
+    def __init__(self, speech_config: speechsdk.SpeechConfig, sample_rate: int) -> None:
+        self._loop = asyncio.get_running_loop()
+        self._queue: asyncio.Queue[Optional[TranscriptEvent]] = asyncio.Queue()
+        self._done = asyncio.Event()
+
+        stream_format = speechsdk.audio.AudioStreamFormat(samples_per_second=sample_rate, bits_per_sample=16, channels=1)
+        self._push_stream = speechsdk.audio.PushAudioInputStream(stream_format=stream_format)
+        audio_config = speechsdk.audio.AudioConfig(stream=self._push_stream)
+        self._recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)
+
+        self._recognizer.recognizing.connect(self._on_recognizing)
+        self._recognizer.recognized.connect(self._on_recognized)
+        self._recognizer.canceled.connect(self._on_canceled)
+        self._recognizer.session_stopped.connect(self._on_session_stopped)
+
+        self._recognizer.start_continuous_recognition_async()
+
+    def _emit(self, event: Optional[TranscriptEvent]) -> None:
+        self._loop.call_soon_threadsafe(self._queue.put_nowait, event)
+
+    def _on_recognizing(self, evt: speechsdk.SpeechRecognitionEventArgs) -> None:
+        text = evt.result.text
+        if text:
+            self._emit(TranscriptEvent(text=text, is_final=False))
+
+    def _on_recognized(self, evt: speechsdk.SpeechRecognitionEventArgs) -> None:
+        if evt.result.reason == speechsdk.ResultReason.RecognizedSpeech:
+            text = evt.result.text
+            if text:
+                self._emit(TranscriptEvent(text=text, is_final=True))
+
+    def _on_canceled(self, _: speechsdk.SpeechRecognitionEventArgs) -> None:
+        self._finish()
+
+    def _on_session_stopped(self, _: speechsdk.SessionEventArgs) -> None:
+        self._finish()
+
+    def _finish(self) -> None:
+        if self._done.is_set():
+            return
+        self._done.set()
+        self._emit(None)
+
+    async def send_audio(self, data: bytes) -> None:
+        if data:
+            self._push_stream.write(data)
+
+    async def end(self) -> None:
+        self._push_stream.close()
+        await asyncio.to_thread(self._recognizer.stop_continuous_recognition_async().get)
+        self._finish()
+
+    async def results(self) -> AsyncIterator[TranscriptEvent]:
+        while True:
+            item = await self._queue.get()
+            if item is None:
+                break
+            yield item
+
+
+class FoundrySTTProvider(STTProvider):
+    async def start_stream(self, sample_rate: int) -> STTStream:
+        speech_config = _speech_config()
+        return FoundrySTTStream(speech_config, sample_rate)

app/providers/azure_foundry_tts.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import AsyncIterator, Optional
+
+import azure.cognitiveservices.speech as speechsdk
+
+from app.observability.logging import get_logger
+from app.providers.tts_base import TTSProvider
+
+
+def _wrap_with_sales_ssml(text: str, voice: str = "en-US-AriaNeural") -> str:
+    """Wrap text with SSML for optimized sales voice styling."""
+    # Don't double-wrap if already SSML
+    if text.strip().startswith("<speak"):
+        return text
+    
+    # Use customerservice style for AriaNeural, friendly for others
+    style = "customerservice" if "Aria" in voice else "friendly"
+    style_degree = "1.2" if "Aria" in voice else "1.0"
+    
+    return f'''<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="en-US">
+    <voice name="{voice}" style="{style}" styledegree="{style_degree}">
+        {text}
+    </voice>
+</speak>'''
+
+
+def _speech_config() -> speechsdk.SpeechConfig:
+    key = os.getenv("SPEECH_KEY")
+    endpoint = os.getenv("ENDPOINT") or os.getenv("SPEECH_ENDPOINT")
+    region = os.getenv("SPEECH_REGION")
+
+    if not key or not (endpoint or region):
+        raise RuntimeError("Missing SPEECH_KEY and ENDPOINT or SPEECH_REGION for Foundry Speech.")
+
+    if endpoint:
+        config = speechsdk.SpeechConfig(subscription=key, endpoint=endpoint)
+    else:
+        config = speechsdk.SpeechConfig(subscription=key, region=region)
+
+    voice = os.getenv("SPEECH_VOICE", "en-US-AriaNeural")
+    config.speech_synthesis_voice_name = voice
+    config.set_speech_synthesis_output_format(
+        speechsdk.SpeechSynthesisOutputFormat.Raw16Khz16BitMonoPcm
+    )
+    return config
+
+
+class FoundryTTSProvider(TTSProvider):
+    async def synthesize_stream(self, text: str, voice: Optional[str] = None) -> AsyncIterator[bytes]:
+        logger = get_logger("tts")
+        speech_config = _speech_config()
+        if voice:
+            speech_config.speech_synthesis_voice_name = voice
+
+        queue: asyncio.Queue[Optional[bytes]] = asyncio.Queue()
+        loop = asyncio.get_running_loop()
+        callback = _StreamingOutputStream(loop, queue)
+        stream = speechsdk.audio.PushAudioOutputStream(callback)
+        audio_config = speechsdk.audio.AudioOutputConfig(stream=stream)
+        synthesizer = speechsdk.SpeechSynthesizer(speech_config=speech_config, audio_config=audio_config)
+
+        # Wrap text with sales-optimized SSML
+        voice_name = voice or speech_config.speech_synthesis_voice_name
+        ssml_text = _wrap_with_sales_ssml(text, voice_name)
+
+        async def _run() -> None:
+            if ssml_text.lstrip().startswith("<speak"):
+                result = await asyncio.to_thread(synthesizer.speak_ssml_async(ssml_text).get)
+            else:
+                result = await asyncio.to_thread(synthesizer.speak_text_async(ssml_text).get)
+            if result.reason != speechsdk.ResultReason.SynthesizingAudioCompleted:
+                if result.reason == speechsdk.ResultReason.Canceled:
+                    details = speechsdk.SpeechSynthesisCancellationDetails.from_result(result)
+                    logger.warning(
+                        "tts_canceled",
+                        reason=str(details.reason),
+                        error_code=str(details.error_code),
+                        error_details=details.error_details,
+                    )
+                else:
+                    logger.warning("tts_failed", reason=str(result.reason))
+                callback.end()
+                return
+            callback.end()
+
+        task = asyncio.create_task(_run())
+
+        sent = 0
+        while True:
+            chunk = await queue.get()
+            if chunk is None:
+                break
+            sent += 1
+            yield chunk
+
+        await task
+        if sent == 0:
+            logger.warning("tts_empty_audio")
+
+
+class _StreamingOutputStream(speechsdk.audio.PushAudioOutputStreamCallback):
+    def __init__(self, loop: asyncio.AbstractEventLoop, queue: asyncio.Queue[Optional[bytes]]) -> None:
+        self._loop = loop
+        self._queue = queue
+        self._closed = False
+
+    def write(self, audio_buffer: memoryview) -> int:
+        data = bytes(audio_buffer)
+        if data:
+            self._loop.call_soon_threadsafe(self._queue.put_nowait, data)
+        return len(audio_buffer)
+
+    def close(self) -> None:
+        self.end()
+
+    def end(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._loop.call_soon_threadsafe(self._queue.put_nowait, None)

app/providers/llm_base.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict
+
+
+@dataclass
+class LLMResult:
+    text: str
+    metadata: Dict[str, str]
+
+
+class LLMProvider:
+    async def generate(self, prompt: str) -> LLMResult:
+        raise NotImplementedError

app/providers/null_stt.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import asyncio
+from typing import AsyncIterator
+
+from app.providers.stt_base import STTProvider, STTStream, TranscriptEvent
+
+
+class NullSTTStream(STTStream):
+    def __init__(self) -> None:
+        self._closed = asyncio.Event()
+
+    async def send_audio(self, _: bytes) -> None:
+        return
+
+    async def end(self) -> None:
+        self._closed.set()
+
+    async def results(self) -> AsyncIterator[TranscriptEvent]:
+        await self._closed.wait()
+        if False:
+            yield TranscriptEvent(text="", is_final=True)
+
+
+class NullSTTProvider(STTProvider):
+    async def start_stream(self, sample_rate: int) -> STTStream:
+        _ = sample_rate
+        return NullSTTStream()

app/providers/null_tts.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import AsyncIterator, Optional
+
+from app.providers.tts_base import TTSProvider
+
+
+class NullTTSProvider(TTSProvider):
+    async def synthesize_stream(self, text: str, voice: Optional[str] = None) -> AsyncIterator[bytes]:
+        _ = text
+        _ = voice
+        if False:
+            yield b""

app/providers/stt_base.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import AsyncIterator, Optional
+
+
+@dataclass
+class TranscriptEvent:
+    text: str
+    is_final: bool
+    confidence: Optional[float] = None
+
+
+class STTStream:
+    async def send_audio(self, _: bytes) -> None:
+        raise NotImplementedError
+
+    async def end(self) -> None:
+        raise NotImplementedError
+
+    async def results(self) -> AsyncIterator[TranscriptEvent]:
+        raise NotImplementedError
+
+
+class STTProvider:
+    async def start_stream(self, sample_rate: int) -> STTStream:
+        raise NotImplementedError

app/providers/tts_base.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from typing import AsyncIterator, Optional
+
+
+class TTSProvider:
+    async def synthesize_stream(self, text: str, voice: Optional[str] = None) -> AsyncIterator[bytes]:
+        raise NotImplementedError

app/sales_brain/brain.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from sales_model.sales_brain import SalesBrain
+from sales_model.schemas import BrainOutput
+
+
+def merge_memory(memory: Dict[str, Any], output: BrainOutput) -> Dict[str, Any]:
+    ex = output.extracted.to_dict()
+    for k, v in ex.items():
+        if v in (None, "", []):
+            continue
+        if k not in memory or memory.get(k) in (None, "", []):
+            memory[k] = v
+    if output.meta:
+        memory["_meta"] = output.meta
+    return memory
+
+
+class SalesBrainEngine:
+    def __init__(self) -> None:
+        self._brain = SalesBrain()
+
+    def run_turn(self, state: str, user_message: str, memory: Dict[str, Any]) -> BrainOutput:
+        return self._brain.run_turn(state, user_message, memory=memory)

app/sales_brain/chunker.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import re
+from typing import Iterable, List
+
+
+def split_sentences(text: str) -> List[str]:
+    if not text:
+        return []
+    return [s.strip() for s in re.split(r"(?<=[.!?])\s+", text.strip()) if s.strip()]
+
+
+def chunk_text(text: str, max_chars: int = 160) -> Iterable[str]:
+    return chunk_text_for_speech(text, max_chars=max_chars, max_sentences=3)
+
+
+def chunk_text_for_speech(text: str, max_chars: int = 160, max_sentences: int = 2) -> Iterable[str]:
+    if not text:
+        return []
+    sentences = split_sentences(text)
+    chunk = ""
+    sentence_count = 0
+    chunks: List[str] = []
+    for sentence in sentences:
+        if not sentence:
+            continue
+        proposed = f"{chunk} {sentence}".strip() if chunk else sentence
+        if (len(proposed) <= max_chars) and (sentence_count < max_sentences):
+            chunk = proposed
+            sentence_count += 1
+            continue
+        if chunk:
+            chunks.append(chunk)
+        if len(sentence) <= max_chars:
+            chunk = sentence
+            sentence_count = 1
+        else:
+            # Hard split long sentences.
+            start = 0
+            while start < len(sentence):
+                end = min(start + max_chars, len(sentence))
+                chunks.append(sentence[start:end].strip())
+                start = end
+            chunk = ""
+            sentence_count = 0
+    if chunk:
+        chunks.append(chunk)
+    return chunks