amd-gaia 0.14.1__py3-none-any.whl

gaia/talk/sdk.py

@@ -0,0 +1,538 @@
+#!/usr/bin/env python3
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+"""
+Gaia Talk SDK - Unified voice and text chat integration
+"""
+
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, AsyncGenerator, Callable, Dict, Optional
+
+from gaia.audio.audio_client import AudioClient
+from gaia.chat.sdk import ChatConfig, ChatSDK
+from gaia.llm.lemonade_client import DEFAULT_MODEL_NAME
+from gaia.logger import get_logger
+
+
+class TalkMode(Enum):
+    """Talk mode options."""
+
+    TEXT_ONLY = "text_only"
+    VOICE_ONLY = "voice_only"
+    VOICE_AND_TEXT = "voice_and_text"
+
+
+@dataclass
+class TalkConfig:
+    """Configuration for TalkSDK."""
+
+    # Voice-specific settings
+    whisper_model_size: str = "base"
+    audio_device_index: Optional[int] = None  # Use default input device
+    silence_threshold: float = 0.5
+    enable_tts: bool = True
+    mode: TalkMode = TalkMode.VOICE_AND_TEXT
+
+    # Chat settings (from ChatConfig)
+    model: str = DEFAULT_MODEL_NAME
+    max_tokens: int = 512
+    system_prompt: Optional[str] = None
+    max_history_length: int = 4  # Number of conversation pairs to keep
+    assistant_name: str = "gaia"
+
+    # General settings
+    use_claude: bool = False  # Use Claude API
+    use_chatgpt: bool = False  # Use ChatGPT/OpenAI API
+    show_stats: bool = False
+    logging_level: str = "INFO"
+
+    # RAG settings (optional - for document Q&A)
+    rag_documents: Optional[list] = None  # PDF documents to index
+
+
+@dataclass
+class TalkResponse:
+    """Response from talk operations."""
+
+    text: str
+    stats: Optional[Dict[str, Any]] = None
+    is_complete: bool = True
+
+
+class TalkSDK:
+    """
+    Gaia Talk SDK - Unified voice and text chat integration.
+
+    This SDK provides a simple interface for integrating Gaia's voice and text
+    chat capabilities into applications.
+
+    Example usage:
+        ```python
+        from gaia.talk.sdk import TalkSDK, TalkConfig
+
+        # Create SDK instance
+        config = TalkConfig(enable_tts=True, show_stats=True)
+        talk = TalkSDK(config)
+
+        # Text chat
+        response = await talk.chat("Hello, how are you?")
+        print(response.text)
+
+        # Streaming chat
+        async for chunk in talk.chat_stream("Tell me a story"):
+            print(chunk.text, end="", flush=True)
+
+        # Voice chat with document Q&A
+        talk_rag = TalkSDK(TalkConfig(enable_tts=True))
+        talk_rag.enable_rag(documents=["manual.pdf", "guide.pdf"])
+        await talk_rag.start_voice_session()
+
+        # Voice chat with callback
+        def on_voice_input(text):
+            print(f"User said: {text}")
+
+        await talk.start_voice_session(on_voice_input)
+        ```
+    """
+
+    def __init__(self, config: Optional[TalkConfig] = None):
+        """
+        Initialize the TalkSDK.
+
+        Args:
+            config: Configuration options. If None, uses defaults.
+        """
+        self.config = config or TalkConfig()
+        self.log = get_logger(__name__)
+        self.log.setLevel(getattr(logging, self.config.logging_level))
+
+        # Initialize ChatSDK for text generation with conversation history
+        chat_config = ChatConfig(
+            model=self.config.model,
+            max_tokens=self.config.max_tokens,
+            system_prompt=self.config.system_prompt,
+            max_history_length=self.config.max_history_length,
+            assistant_name=self.config.assistant_name,
+            show_stats=self.config.show_stats,
+            logging_level=self.config.logging_level,
+            use_claude=self.config.use_claude,
+            use_chatgpt=self.config.use_chatgpt,
+        )
+        self.chat_sdk = ChatSDK(chat_config)
+
+        # Initialize AudioClient with configuration (for voice features)
+        self.audio_client = AudioClient(
+            whisper_model_size=self.config.whisper_model_size,
+            audio_device_index=self.config.audio_device_index,
+            silence_threshold=self.config.silence_threshold,
+            enable_tts=self.config.enable_tts,
+            logging_level=self.config.logging_level,
+            use_claude=self.config.use_claude,
+            use_chatgpt=self.config.use_chatgpt,
+            system_prompt=self.config.system_prompt,
+        )
+
+        self.show_stats = self.config.show_stats
+        self._voice_session_active = False
+
+        # Enable RAG if documents are provided
+        if self.config.rag_documents:
+            self.enable_rag(documents=self.config.rag_documents)
+
+        self.log.info("TalkSDK initialized with ChatSDK integration")
+
+    async def chat(self, message: str) -> TalkResponse:
+        """
+        Send a text message and get a complete response.
+
+        Args:
+            message: The message to send
+
+        Returns:
+            TalkResponse with the complete response
+        """
+        try:
+            # Use ChatSDK for text generation (with conversation history)
+            chat_response = self.chat_sdk.send(message)
+
+            stats = None
+            if self.show_stats:
+                stats = chat_response.stats or self.get_stats()
+
+            return TalkResponse(text=chat_response.text, stats=stats, is_complete=True)
+
+        except Exception as e:
+            self.log.error(f"Error in chat: {e}")
+            raise
+
+    async def chat_stream(self, message: str) -> AsyncGenerator[TalkResponse, None]:
+        """
+        Send a text message and get a streaming response.
+
+        Args:
+            message: The message to send
+
+        Yields:
+            TalkResponse chunks as they arrive
+        """
+        try:
+            # Use ChatSDK for streaming text generation (with conversation history)
+            for chat_chunk in self.chat_sdk.send_stream(message):
+                if not chat_chunk.is_complete:
+                    yield TalkResponse(text=chat_chunk.text, is_complete=False)
+                else:
+                    # Final chunk with stats
+                    stats = chat_chunk.stats if self.show_stats else None
+                    yield TalkResponse(text="", stats=stats, is_complete=True)
+
+        except Exception as e:
+            self.log.error(f"Error in chat_stream: {e}")
+            raise
+
+    async def process_voice_input(self, text: str) -> TalkResponse:
+        """
+        Process voice input text through the complete voice pipeline.
+
+        This includes TTS output if enabled.
+
+        Args:
+            text: The transcribed voice input
+
+        Returns:
+            TalkResponse with the processed response
+        """
+        try:
+            # Use ChatSDK to generate response (with conversation history)
+            chat_response = self.chat_sdk.send(text)
+
+            # If TTS is enabled, speak the response
+            if self.config.enable_tts and getattr(self.audio_client, "tts", None):
+                await self.audio_client.speak_text(chat_response.text)
+
+            stats = None
+            if self.show_stats:
+                stats = chat_response.stats or self.get_stats()
+
+            return TalkResponse(text=chat_response.text, stats=stats, is_complete=True)
+
+        except Exception as e:
+            self.log.error(f"Error processing voice input: {e}")
+            raise
+
+    async def start_voice_session(
+        self,
+        on_voice_input: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        """
+        Start an interactive voice session.
+
+        Args:
+            on_voice_input: Optional callback called when voice input is detected
+        """
+        try:
+            self._voice_session_active = True
+
+            # Initialize TTS if enabled
+            self.audio_client.initialize_tts()
+
+            # Create voice processor that uses ChatSDK for responses
+            async def voice_processor(text: str):
+                # Call user callback if provided
+                if on_voice_input:
+                    on_voice_input(text)
+
+                # Use ChatSDK to generate response (with conversation history)
+                chat_response = self.chat_sdk.send(text)
+
+                # If TTS is enabled, speak the response
+                if self.config.enable_tts and getattr(self.audio_client, "tts", None):
+                    await self.audio_client.speak_text(chat_response.text)
+
+                # Print the response for user feedback
+                print(f"{self.config.assistant_name.title()}: {chat_response.text}")
+
+                # Show stats if enabled
+                if self.show_stats and chat_response.stats:
+                    print(f"Stats: {chat_response.stats}")
+
+            # Start voice chat session with our processor
+            await self.audio_client.start_voice_chat(voice_processor)
+
+        except KeyboardInterrupt:
+            self.log.info("Voice session interrupted by user")
+        except Exception as e:
+            self.log.error(f"Error in voice session: {e}")
+            raise
+        finally:
+            self._voice_session_active = False
+            self.log.info("Voice chat session ended")
+
+    async def halt_generation(self) -> None:
+        """Halt the current LLM generation."""
+        try:
+            await self.audio_client.halt_generation()
+        except Exception as e:
+            self.log.error(f"Error halting generation: {e}")
+            raise
+
+    def get_stats(self) -> Dict[str, Any]:
+        """
+        Get performance statistics.
+
+        Returns:
+            Dictionary of performance stats
+        """
+        try:
+            # Get stats from ChatSDK instead of directly from LLMClient
+            return self.chat_sdk.get_stats()
+        except Exception as e:
+            self.log.warning(f"Failed to get stats: {e}")
+            return {}
+
+    def update_config(self, **kwargs) -> None:
+        """
+        Update configuration dynamically.
+
+        Args:
+            **kwargs: Configuration parameters to update
+        """
+        # Update our config
+        for key, value in kwargs.items():
+            if hasattr(self.config, key):
+                setattr(self.config, key, value)
+
+        # Update show_stats
+        if "show_stats" in kwargs:
+            self.show_stats = kwargs["show_stats"]
+
+        # Update AudioClient configuration
+        if "silence_threshold" in kwargs:
+            self.audio_client.silence_threshold = kwargs["silence_threshold"]
+
+        # Update ChatSDK configuration
+        chat_updates = {}
+        if "system_prompt" in kwargs:
+            chat_updates["system_prompt"] = kwargs["system_prompt"]
+            # Also update AudioClient's system prompt for consistency
+            self.audio_client.llm_client.system_prompt = kwargs["system_prompt"]
+        if "max_tokens" in kwargs:
+            chat_updates["max_tokens"] = kwargs["max_tokens"]
+        if "max_history_length" in kwargs:
+            chat_updates["max_history_length"] = kwargs["max_history_length"]
+        if "assistant_name" in kwargs:
+            chat_updates["assistant_name"] = kwargs["assistant_name"]
+
+        if chat_updates:
+            self.chat_sdk.update_config(**chat_updates)
+
+    def clear_history(self) -> None:
+        """Clear the conversation history."""
+        self.chat_sdk.clear_history()
+        self.log.debug("Conversation history cleared")
+
+    def get_history(self) -> list:
+        """Get the current conversation history."""
+        return self.chat_sdk.get_history()
+
+    def get_formatted_history(self) -> list:
+        """Get the conversation history in structured format."""
+        return self.chat_sdk.get_formatted_history()
+
+    def enable_rag(self, documents: Optional[list] = None, **rag_kwargs) -> bool:
+        """
+        Enable RAG (Retrieval-Augmented Generation) for document-based voice/text chat.
+
+        Args:
+            documents: List of PDF file paths to index
+            **rag_kwargs: Additional RAG configuration options
+
+        Returns:
+            True if RAG was successfully enabled
+        """
+        try:
+            self.chat_sdk.enable_rag(documents=documents, **rag_kwargs)
+            self.log.info(
+                f"RAG enabled with {len(documents) if documents else 0} documents"
+            )
+            return True
+        except ImportError:
+            self.log.warning(
+                'RAG dependencies not available. Install with: pip install -e ".[rag]"'
+            )
+            return False
+        except Exception as e:
+            self.log.error(f"Failed to enable RAG: {e}")
+            return False
+
+    def disable_rag(self) -> None:
+        """Disable RAG functionality."""
+        self.chat_sdk.disable_rag()
+        self.log.info("RAG disabled")
+
+    def add_document(self, document_path: str) -> bool:
+        """
+        Add a document to the RAG index.
+
+        Args:
+            document_path: Path to PDF file to index
+
+        Returns:
+            True if document was successfully added
+        """
+        if not self.chat_sdk.rag_enabled:
+            self.log.warning("RAG not enabled. Call enable_rag() first.")
+            return False
+
+        try:
+            return self.chat_sdk.add_document(document_path)
+        except Exception as e:
+            self.log.error(f"Failed to add document {document_path}: {e}")
+            return False
+
+    @property
+    def is_voice_session_active(self) -> bool:
+        """Check if a voice session is currently active."""
+        return self._voice_session_active
+
+    @property
+    def audio_devices(self) -> list:
+        """Get list of available audio input devices."""
+        try:
+            from gaia.audio.audio_recorder import AudioRecorder
+
+            recorder = AudioRecorder()
+            return recorder.list_audio_devices()
+        except Exception as e:
+            self.log.error(f"Error listing audio devices: {e}")
+            return []
+
+
+class SimpleTalk:
+    """
+    Ultra-simple interface for quick integration.
+
+    Example usage:
+        ```python
+        from gaia.talk.sdk import SimpleTalk
+
+        talk = SimpleTalk()
+
+        # Simple text chat
+        response = await talk.ask("What's the weather like?")
+        print(response)
+
+        # Simple voice chat
+        await talk.voice_chat()  # Starts interactive session
+        ```
+    """
+
+    def __init__(
+        self,
+        system_prompt: Optional[str] = None,
+        enable_tts: bool = True,
+        assistant_name: str = "gaia",
+    ):
+        """
+        Initialize SimpleTalk with minimal configuration.
+
+        Args:
+            system_prompt: Optional system prompt for the AI
+            enable_tts: Whether to enable text-to-speech
+            assistant_name: Name to use for the assistant
+        """
+        config = TalkConfig(
+            system_prompt=system_prompt,
+            enable_tts=enable_tts,
+            assistant_name=assistant_name,
+            show_stats=False,
+            logging_level="WARNING",  # Minimal logging
+        )
+        self._sdk = TalkSDK(config)
+
+    async def ask(self, question: str) -> str:
+        """
+        Ask a question and get a text response.
+
+        Args:
+            question: The question to ask
+
+        Returns:
+            The AI's response as a string
+        """
+        response = await self._sdk.chat(question)
+        return response.text
+
+    async def ask_stream(self, question: str):
+        """
+        Ask a question and get a streaming response.
+
+        Args:
+            question: The question to ask
+
+        Yields:
+            Response chunks as they arrive
+        """
+        async for chunk in self._sdk.chat_stream(question):
+            if not chunk.is_complete:
+                yield chunk.text
+
+    async def voice_chat(self) -> None:
+        """Start an interactive voice chat session."""
+        print("Starting voice chat... Say 'stop' to quit or press Ctrl+C")
+
+        def on_voice_input(text: str):
+            print(f"You: {text}")
+
+        await self._sdk.start_voice_session(on_voice_input)
+
+    def clear_memory(self) -> None:
+        """Clear the conversation memory."""
+        self._sdk.clear_history()
+
+    def get_conversation(self) -> list:
+        """Get the conversation history in a readable format."""
+        return self._sdk.get_formatted_history()
+
+
+# Convenience functions for one-off usage
+async def quick_chat(
+    message: str, system_prompt: Optional[str] = None, assistant_name: str = "gaia"
+) -> str:
+    """
+    Quick one-off text chat with conversation memory.
+
+    Args:
+        message: Message to send
+        system_prompt: Optional system prompt
+        assistant_name: Name to use for the assistant
+
+    Returns:
+        AI response
+    """
+    config = TalkConfig(
+        system_prompt=system_prompt,
+        assistant_name=assistant_name,
+        enable_tts=False,
+        logging_level="WARNING",
+        max_history_length=2,  # Small history for quick chat
+    )
+    sdk = TalkSDK(config)
+    response = await sdk.chat(message)
+    return response.text
+
+
+async def quick_voice_chat(
+    system_prompt: Optional[str] = None, assistant_name: str = "gaia"
+) -> None:
+    """
+    Quick one-off voice chat session with conversation memory.
+
+    Args:
+        system_prompt: Optional system prompt
+        assistant_name: Name to use for the assistant
+    """
+    simple = SimpleTalk(system_prompt=system_prompt, assistant_name=assistant_name)
+    await simple.voice_chat()

gaia/util.py

@@ -0,0 +1,46 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+import subprocess
+import time
+
+
+def kill_process_on_port(port):
+    """Kill any process running on the specified port."""
+    try:
+        # Find process using the port
+        result = subprocess.run(
+            f"netstat -ano | findstr :{port}",
+            shell=True,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        if result.stdout:
+            # Extract PID
+            pids_to_kill = set()
+            for line in result.stdout.strip().split("\n"):
+                if f":{port}" in line and (
+                    "LISTENING" in line or "ESTABLISHED" in line
+                ):
+                    parts = line.strip().split()
+                    if len(parts) > 4:
+                        pid = parts[-1]
+                        pids_to_kill.add(pid)
+
+            # Kill each process found
+            for pid in pids_to_kill:
+                print(f"Found process with PID {pid} on port {port}")
+                try:
+                    # Kill the process
+                    subprocess.run(f"taskkill /F /PID {pid}", shell=True, check=False)
+                    print(f"Killed process with PID {pid}")
+                except Exception as e:
+                    print(f"Error killing PID {pid}: {e}")
+
+            # Give the OS some time to free the port
+            if pids_to_kill:
+                time.sleep(2)
+    except Exception as e:
+        print(f"Error killing process on port {port}: {e}")

gaia/version.py

@@ -0,0 +1,100 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+import logging
+import os
+import subprocess
+from importlib.metadata import version as get_package_version_metadata
+
+__version__ = "0.14.1"
+
+# Lemonade version used across CI and installer
+LEMONADE_VERSION = "9.1.0"
+
+
+def get_package_version() -> str:
+    """Get the installed package version from importlib.metadata.
+
+    Returns:
+        str: The package version string
+    """
+    try:
+        return get_package_version_metadata("amd-gaia")
+    except Exception as e:
+        logging.warning(f"Failed to get package version: {e}")
+        return ""
+
+
+def get_git_hash(hash_length: int = 8) -> str:
+    """Get the current git hash.
+    Only used during build/installer process.
+
+    Args:
+        hash_length: Length of the hash to return
+
+    Returns:
+        str: The git hash or 'unknown' if git is not available
+    """
+    try:
+        git_hash = subprocess.check_output(
+            ["git", "rev-parse", "--short", "HEAD"],
+            stderr=subprocess.DEVNULL,
+            text=True,
+        ).strip()
+        return git_hash[:hash_length]
+    except Exception:
+        logging.warning("Failed to get Git hash")
+        return ""
+
+
+def get_version_with_hash() -> str:
+    """Get the full version string including git hash.
+    Only used during build/installer process.
+
+    Returns:
+        str: Version string in format 'v{version}+{hash}'
+    """
+    git_hash = get_git_hash()
+    if git_hash:
+        return f"v{__version__}+{git_hash}"
+    else:
+        return f"v{__version__}"
+
+
+def write_version_files() -> None:
+    """Write version information to version.txt and installer/version.nsh files.
+    Only used during build/installer process."""
+    try:
+        # Write version with hash to version.txt
+        with open("version.txt", "w", encoding="utf-8") as f:
+            f.write(get_version_with_hash())
+
+        # Write version with hash to installer/version.nsh
+        installer_dir = os.path.join("installer")
+        os.makedirs(installer_dir, exist_ok=True)
+        with open(
+            os.path.join(installer_dir, "version.nsh"), "w", encoding="utf-8"
+        ) as f:
+            f.write(f'!define GAIA_VERSION "{get_version_with_hash()}"\n')
+            f.write(f'!define LEMONADE_VERSION "{LEMONADE_VERSION}"\n')
+
+        print(
+            "Version files created successfully: version.txt and installer/version.nsh"
+        )
+    except Exception as e:
+        print(f"Failed to write version files: {str(e)}")
+        raise
+
+
+# For regular package usage - just version number
+version = get_package_version()
+
+
+def main():
+    """Generate version files when the script is run directly.
+    Only used during build/installer process."""
+    write_version_files()
+
+
+if __name__ == "__main__":
+    main()