@agentunion/kite 1.0.6 → 1.2.0

package/extensions/services/web/vendor/conversation/mcp_tools.py

@@ -0,0 +1,190 @@
+"""MCP tool definitions for in-call use by the LLM."""
+
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Canonical tool definitions (provider-agnostic)
+# ---------------------------------------------------------------------------
+
+MCP_TOOLS: list[dict[str, Any]] = [
+    {
+        "name": "confirm_with_caller",
+        "description": (
+            "Ask the task caller to confirm something or provide information. "
+            "Use when you need to verify details with the person who initiated "
+            "this call task."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "question": {
+                    "type": "string",
+                    "description": "The question to ask the caller",
+                },
+                "options": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Optional multiple-choice answers",
+                },
+                "urgent": {
+                    "type": "boolean",
+                    "default": False,
+                    "description": "Whether this requires an immediate response",
+                },
+            },
+            "required": ["question"],
+        },
+    },
+    {
+        "name": "send_sms",
+        "description": "Send an SMS message to a phone number.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "phone_number": {
+                    "type": "string",
+                    "description": "The recipient phone number",
+                },
+                "content": {
+                    "type": "string",
+                    "description": "The SMS text content",
+                },
+            },
+            "required": ["phone_number", "content"],
+        },
+    },
+    {
+        "name": "add_contact",
+        "description": "Add a new contact to the address book.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Contact name",
+                },
+                "phone": {
+                    "type": "string",
+                    "description": "Contact phone number",
+                },
+                "company": {
+                    "type": "string",
+                    "description": "Company or organization name",
+                },
+                "notes": {
+                    "type": "string",
+                    "description": "Additional notes about this contact",
+                },
+            },
+            "required": ["name", "phone"],
+        },
+    },
+    {
+        "name": "search_contacts",
+        "description": "Search the contact list by name, phone, or company.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "Search query string",
+                },
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "notify_caller",
+        "description": (
+            "Send a one-way notification to the task caller. "
+            "No reply is expected."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Notification message content",
+                },
+            },
+            "required": ["message"],
+        },
+    },
+]
+
+
+# ---------------------------------------------------------------------------
+# Provider-specific format converters
+# ---------------------------------------------------------------------------
+
+def get_tools_for_provider(provider: str) -> list[dict[str, Any]]:
+    """Convert ``MCP_TOOLS`` into the tool schema expected by each LLM provider.
+
+    Parameters
+    ----------
+    provider:
+        One of ``"openai"``, ``"claude"``, or ``"gemini"``.
+
+    Returns
+    -------
+    A list of tool definitions in the target provider's native format.
+    """
+    if provider == "openai":
+        return _to_openai_format()
+    elif provider == "claude":
+        return _to_claude_format()
+    elif provider == "gemini":
+        return _to_gemini_format()
+    else:
+        raise ValueError(f"Unknown provider: {provider}")
+
+
+def _to_openai_format() -> list[dict[str, Any]]:
+    """OpenAI / OpenAI-compatible format.
+
+    Each tool is wrapped in ``{"type": "function", "function": {...}}``.
+    """
+    tools: list[dict[str, Any]] = []
+    for tool in MCP_TOOLS:
+        tools.append({
+            "type": "function",
+            "function": {
+                "name": tool["name"],
+                "description": tool["description"],
+                "parameters": copy.deepcopy(tool["parameters"]),
+            },
+        })
+    return tools
+
+
+def _to_claude_format() -> list[dict[str, Any]]:
+    """Anthropic Claude format.
+
+    Each tool uses ``{"name": ..., "description": ..., "input_schema": ...}``.
+    """
+    tools: list[dict[str, Any]] = []
+    for tool in MCP_TOOLS:
+        tools.append({
+            "name": tool["name"],
+            "description": tool["description"],
+            "input_schema": copy.deepcopy(tool["parameters"]),
+        })
+    return tools
+
+
+def _to_gemini_format() -> list[dict[str, Any]]:
+    """Google Gemini format.
+
+    Returns ``[{"function_declarations": [...]}]``.
+    """
+    declarations: list[dict[str, Any]] = []
+    for tool in MCP_TOOLS:
+        declarations.append({
+            "name": tool["name"],
+            "description": tool["description"],
+            "parameters": copy.deepcopy(tool["parameters"]),
+        })
+    return [{"function_declarations": declarations}]

package/extensions/services/web/vendor/conversation/tts.py

@@ -0,0 +1,322 @@
+"""TTS (Text-to-Speech) abstraction with multiple provider implementations."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import logging
+import time
+import uuid
+from abc import ABC, abstractmethod
+from datetime import datetime, timezone
+from typing import Any
+
+import httpx
+
+from .. import config as cfg
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Abstract base
+# ---------------------------------------------------------------------------
+
+class TTSProvider(ABC):
+    """Base class for all TTS (text-to-speech) providers."""
+
+    @abstractmethod
+    async def synthesize(self, text: str, language: str = "zh") -> bytes:
+        """Synthesize *text* into audio bytes.
+
+        Returns MP3-encoded audio data.  Callers that need raw PCM should
+        decode separately (e.g. via ffmpeg or a pure-Python decoder).
+        """
+        ...
+
+
+# ---------------------------------------------------------------------------
+# Edge-TTS (Microsoft Edge online TTS, free)
+# ---------------------------------------------------------------------------
+
+class EdgeTTSProvider(TTSProvider):
+    """Microsoft Edge TTS via the ``edge-tts`` library (free)."""
+
+    def __init__(
+        self,
+        voice: str = "zh-CN-XiaoxiaoNeural",
+        rate: str = "+0%",
+        volume: str = "+0%",
+    ) -> None:
+        self.voice = voice
+        self.rate = rate
+        self.volume = volume
+
+    async def synthesize(self, text: str, language: str = "zh") -> bytes:
+        if not text or not text.strip():
+            return b""
+        import edge_tts
+
+        communicate = edge_tts.Communicate(
+            text=text,
+            voice=self.voice,
+            rate=self.rate,
+            volume=self.volume,
+        )
+
+        audio_chunks: list[bytes] = []
+        async for chunk in communicate.stream():
+            if chunk["type"] == "audio":
+                audio_chunks.append(chunk["data"])
+
+        return b"".join(audio_chunks)
+
+
+
+# ---------------------------------------------------------------------------
+# Volcengine TTS (火山引擎)
+# ---------------------------------------------------------------------------
+
+class VolcengineTTSProvider(TTSProvider):
+    """Volcengine (ByteDance) TTS via HTTP API."""
+
+    API_URL = "https://openspeech.bytedance.com/api/v1/tts"
+
+    def __init__(
+        self,
+        app_id: str = "",
+        access_token: str = "",
+        cluster: str = "volcano_tts",
+        voice_type: str = "BV001_streaming",
+        speed_ratio: float = 1.0,
+        volume_ratio: float = 1.0,
+        pitch_ratio: float = 1.0,
+        encoding: str = "mp3",
+        sample_rate: int = 24000,
+    ) -> None:
+        self.app_id = app_id
+        self.access_token = access_token
+        self.cluster = cluster
+        self.voice_type = voice_type
+        self.speed_ratio = speed_ratio
+        self.volume_ratio = volume_ratio
+        self.pitch_ratio = pitch_ratio
+        self.encoding = encoding
+        self.sample_rate = sample_rate
+
+    async def synthesize(self, text: str, language: str = "zh") -> bytes:
+        if not text or not text.strip():
+            return b""
+
+        payload = {
+            "app": {
+                "appid": self.app_id,
+                "token": self.access_token,
+                "cluster": self.cluster,
+            },
+            "user": {"uid": "tts-test"},
+            "audio": {
+                "voice_type": self.voice_type,
+                "encoding": self.encoding,
+                "speed_ratio": self.speed_ratio,
+                "volume_ratio": self.volume_ratio,
+                "pitch_ratio": self.pitch_ratio,
+                "sample_rate": self.sample_rate,
+            },
+            "request": {
+                "reqid": str(uuid.uuid4()),
+                "text": text,
+                "operation": "query",
+            },
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer;{self.access_token}",
+        }
+
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.post(self.API_URL, json=payload, headers=headers)
+            resp.raise_for_status()
+            result = resp.json()
+
+        if result.get("code") != 3000:
+            msg = result.get("message", "unknown error")
+            raise RuntimeError(f"Volcengine TTS error: {msg} (code={result.get('code')})")
+
+        audio_b64 = result.get("data", "")
+        if not audio_b64:
+            raise RuntimeError("Volcengine TTS returned empty audio data")
+
+        return base64.b64decode(audio_b64)
+
+
+# ---------------------------------------------------------------------------
+# Tencent Cloud TTS (腾讯云)
+# ---------------------------------------------------------------------------
+
+class TencentTTSProvider(TTSProvider):
+    """Tencent Cloud TTS via HTTP API (TextToVoice action)."""
+
+    API_HOST = "tts.tencentcloudapi.com"
+    SERVICE = "tts"
+    ACTION = "TextToVoice"
+    VERSION = "2019-08-23"
+
+    def __init__(
+        self,
+        secret_id: str = "",
+        secret_key: str = "",
+        app_id: int = 0,
+        voice_type: int = 101001,
+        codec: str = "pcm",
+        sample_rate: int = 16000,
+        speed: float = 0,
+        volume: float = 0,
+    ) -> None:
+        self.secret_id = secret_id
+        self.secret_key = secret_key
+        self.app_id = app_id
+        self.voice_type = voice_type
+        self.codec = codec
+        self.sample_rate = sample_rate
+        self.speed = speed
+        self.volume = volume
+
+    def _sign(self, payload_json: str, timestamp: int) -> dict[str, str]:
+        """Build TC3-HMAC-SHA256 signed headers."""
+        date = datetime.fromtimestamp(timestamp, tz=timezone.utc).strftime("%Y-%m-%d")
+
+        # 1. Canonical request
+        ct = "application/json; charset=utf-8"
+        canonical = (
+            f"POST\n/\n\n"
+            f"content-type:{ct}\n"
+            f"host:{self.API_HOST}\n"
+            f"x-tc-action:{self.ACTION.lower()}\n\n"
+            f"content-type;host;x-tc-action\n"
+            f"{hashlib.sha256(payload_json.encode()).hexdigest()}"
+        )
+
+        # 2. String to sign
+        scope = f"{date}/{self.SERVICE}/tc3_request"
+        string_to_sign = (
+            f"TC3-HMAC-SHA256\n{timestamp}\n{scope}\n"
+            f"{hashlib.sha256(canonical.encode()).hexdigest()}"
+        )
+
+        # 3. Signing key
+        def _hmac_sha256(key: bytes, msg: str) -> bytes:
+            return hmac.new(key, msg.encode(), hashlib.sha256).digest()
+
+        secret_date = _hmac_sha256(f"TC3{self.secret_key}".encode(), date)
+        secret_service = _hmac_sha256(secret_date, self.SERVICE)
+        secret_signing = _hmac_sha256(secret_service, "tc3_request")
+        signature = hmac.new(secret_signing, string_to_sign.encode(), hashlib.sha256).hexdigest()
+
+        auth = (
+            f"TC3-HMAC-SHA256 Credential={self.secret_id}/{scope}, "
+            f"SignedHeaders=content-type;host;x-tc-action, "
+            f"Signature={signature}"
+        )
+
+        return {
+            "Content-Type": ct,
+            "Host": self.API_HOST,
+            "X-TC-Action": self.ACTION,
+            "X-TC-Version": self.VERSION,
+            "X-TC-Timestamp": str(timestamp),
+            "Authorization": auth,
+        }
+
+    async def synthesize(self, text: str, language: str = "zh") -> bytes:
+        if not text or not text.strip():
+            return b""
+
+        session_id = str(uuid.uuid4()).replace("-", "")
+        payload = {
+            "Text": text,
+            "SessionId": session_id,
+            "Volume": self.volume,
+            "Speed": self.speed,
+            "VoiceType": self.voice_type,
+            "Codec": self.codec,
+            "SampleRate": self.sample_rate,
+            "ModelType": 1,
+        }
+
+        payload_json = json.dumps(payload)
+        timestamp = int(time.time())
+        headers = self._sign(payload_json, timestamp)
+
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.post(
+                f"https://{self.API_HOST}",
+                content=payload_json,
+                headers=headers,
+            )
+            resp.raise_for_status()
+            result = resp.json()
+
+        response = result.get("Response", {})
+        if response.get("Error"):
+            err = response["Error"]
+            raise RuntimeError(
+                f"Tencent TTS error: {err.get('Message', '')} ({err.get('Code', '')})"
+            )
+
+        audio_b64 = response.get("Audio", "")
+        if not audio_b64:
+            raise RuntimeError("Tencent TTS returned empty audio data")
+
+        return base64.b64decode(audio_b64)
+
+
+# ---------------------------------------------------------------------------
+# Factory
+# ---------------------------------------------------------------------------
+
+def create_tts_provider(provider: str | None = None, **overrides: Any) -> TTSProvider:
+    """Create a TTS provider instance.
+
+    If *provider* is ``None``, the value from config is used.
+    Extra *overrides* are merged on top of config values.
+    """
+    if provider is None:
+        provider = cfg.get("tts.provider", "edge-tts")
+
+    if provider == "edge-tts":
+        return EdgeTTSProvider(
+            voice=overrides.get("voice", cfg.get("tts.edge_tts.voice", "zh-CN-XiaoxiaoNeural")),
+            rate=overrides.get("rate", cfg.get("tts.edge_tts.rate", "+0%")),
+            volume=overrides.get("volume", cfg.get("tts.edge_tts.volume", "+0%")),
+        )
+
+    if provider == "volcengine":
+        return VolcengineTTSProvider(
+            app_id=overrides.get("app_id", cfg.get("tts.volcengine.app_id") or cfg.get("asr.volcengine.app_id", "")),
+            access_token=overrides.get("access_token", cfg.get("tts.volcengine.access_token") or cfg.get("asr.volcengine.access_token", "")),
+            cluster=overrides.get("cluster", cfg.get("tts.volcengine.cluster", "volcano_tts")),
+            voice_type=overrides.get("voice_type", cfg.get("tts.volcengine.voice_type", "BV001_streaming")),
+            speed_ratio=float(overrides.get("speed_ratio", cfg.get("tts.volcengine.speed_ratio", 1.0))),
+            volume_ratio=float(overrides.get("volume_ratio", cfg.get("tts.volcengine.volume_ratio", 1.0))),
+            pitch_ratio=float(overrides.get("pitch_ratio", cfg.get("tts.volcengine.pitch_ratio", 1.0))),
+            encoding=overrides.get("encoding", cfg.get("tts.volcengine.encoding", "mp3")),
+            sample_rate=int(overrides.get("sample_rate", cfg.get("tts.volcengine.sample_rate", 24000))),
+        )
+
+    if provider == "tencent":
+        return TencentTTSProvider(
+            secret_id=overrides.get("secret_id", cfg.get("tts.tencent.secret_id") or cfg.get("asr.tencent.secret_id", "")),
+            secret_key=overrides.get("secret_key", cfg.get("tts.tencent.secret_key") or cfg.get("asr.tencent.secret_key", "")),
+            app_id=int(overrides.get("app_id", cfg.get("tts.tencent.app_id") or cfg.get("asr.tencent.app_id", 0))),
+            voice_type=int(overrides.get("voice_type", cfg.get("tts.tencent.voice_type", 101001))),
+            codec=overrides.get("codec", cfg.get("tts.tencent.codec", "pcm")),
+            sample_rate=int(overrides.get("sample_rate", cfg.get("tts.tencent.sample_rate", 16000))),
+            speed=float(overrides.get("speed", cfg.get("tts.tencent.speed", 0))),
+            volume=float(overrides.get("volume", cfg.get("tts.tencent.volume", 0))),
+        )
+
+    raise ValueError(f"Unknown TTS provider: {provider}")

package/extensions/services/web/vendor/conversation/vad.py

@@ -0,0 +1,138 @@
+"""Voice Activity Detection (VAD) using webrtcvad."""
+
+from __future__ import annotations
+
+import logging
+
+import webrtcvad
+
+from .. import config as cfg
+
+logger = logging.getLogger(__name__)
+
+
+class VADDetector:
+    """Frame-level voice activity detector backed by ``webrtcvad``.
+
+    Feed it 16 kHz S16LE mono PCM frames and it will emit events:
+
+    * ``"speech_start"`` -- the user started speaking
+    * ``"speech_end"``   -- the user stopped speaking (silence exceeded threshold)
+    * ``None``           -- no state change
+
+    webrtcvad requires frames of exactly 10, 20, or 30 ms.  At 16 kHz S16LE
+    mono that corresponds to 320, 640, or 960 bytes respectively.  If the
+    caller supplies frames of a different length they will be buffered
+    internally and split into 20 ms chunks.
+    """
+
+    # At 16 kHz S16LE mono: 20 ms = 640 bytes
+    FRAME_DURATION_MS = 20
+    BYTES_PER_FRAME = 640  # 16000 * 2 * 20 / 1000
+
+    def __init__(
+        self,
+        mode: int = 3,
+        sample_rate: int = 16000,
+        silence_threshold_ms: int = 800,
+        min_speech_ms: int = 250,
+    ) -> None:
+        """
+        Parameters
+        ----------
+        mode:
+            webrtcvad aggressiveness (0-3). Higher = more aggressive filtering.
+        sample_rate:
+            Audio sample rate in Hz (must be 8000, 16000, 32000, or 48000).
+        silence_threshold_ms:
+            How many milliseconds of silence before emitting ``speech_end``.
+        min_speech_ms:
+            Minimum speech duration before we consider it real speech
+            (avoids false triggers on short noise bursts).
+        """
+        self._vad = webrtcvad.Vad(mode)
+        self._sample_rate = sample_rate
+        self._silence_threshold_ms = silence_threshold_ms
+        self._min_speech_ms = min_speech_ms
+
+        # How many *consecutive* silent frames required to declare end-of-speech
+        self._silence_frames_needed = silence_threshold_ms // self.FRAME_DURATION_MS
+        # How many *consecutive* speech frames required to declare start-of-speech
+        self._speech_frames_needed = max(1, min_speech_ms // self.FRAME_DURATION_MS)
+
+        # Internal state
+        self._in_speech = False
+        self._speech_frame_count = 0
+        self._silence_frame_count = 0
+        self._buffer = bytearray()
+
+    def feed(self, chunk: bytes) -> str | None:
+        """Feed audio data and return an event string or ``None``.
+
+        The chunk can be any size; it will be buffered internally and
+        processed in 20 ms frames.  Only the *last* event produced by
+        the batch is returned (to keep the API simple).
+        """
+        self._buffer.extend(chunk)
+        last_event: str | None = None
+
+        while len(self._buffer) >= self.BYTES_PER_FRAME:
+            frame = bytes(self._buffer[: self.BYTES_PER_FRAME])
+            self._buffer = self._buffer[self.BYTES_PER_FRAME :]
+            event = self._process_frame(frame)
+            if event is not None:
+                last_event = event
+
+        return last_event
+
+    def reset(self) -> None:
+        """Reset detector state for a new utterance."""
+        self._in_speech = False
+        self._speech_frame_count = 0
+        self._silence_frame_count = 0
+        self._buffer = bytearray()
+
+    # ------------------------------------------------------------------
+
+    def _process_frame(self, frame: bytes) -> str | None:
+        """Process a single 20 ms frame."""
+        try:
+            is_speech = self._vad.is_speech(frame, self._sample_rate)
+        except Exception:
+            # webrtcvad can raise on malformed frames; treat as silence
+            is_speech = False
+
+        if is_speech:
+            self._silence_frame_count = 0
+            self._speech_frame_count += 1
+
+            if not self._in_speech and self._speech_frame_count >= self._speech_frames_needed:
+                self._in_speech = True
+                logger.debug("VAD: speech_start (after %d frames)", self._speech_frame_count)
+                return "speech_start"
+        else:
+            self._speech_frame_count = 0
+            if self._in_speech:
+                self._silence_frame_count += 1
+                if self._silence_frame_count >= self._silence_frames_needed:
+                    self._in_speech = False
+                    self._silence_frame_count = 0
+                    logger.debug("VAD: speech_end")
+                    return "speech_end"
+
+        return None
+
+    @property
+    def is_speaking(self) -> bool:
+        """``True`` if the detector currently believes the user is speaking."""
+        return self._in_speech
+
+
+def create_vad_detector() -> VADDetector:
+    """Create a VAD detector instance based on the current configuration."""
+    return VADDetector(
+        mode=cfg.get("vad.mode", 3),
+        sample_rate=cfg.get("audio.sample_rate", 16000),
+        silence_threshold_ms=cfg.get("vad.silence_threshold_ms", 800),
+        min_speech_ms=cfg.get("vad.min_speech_ms", 250),
+    )

package/extensions/services/web/vendor/storage/__init__.py

@@ -0,0 +1 @@
+from .store import *  # noqa: F401,F403