amd-gaia 0.14.1__py3-none-any.whl

gaia/security.py

@@ -0,0 +1,163 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""
+Security utilities for GAIA.
+Handles path validation, user prompting, and persistent allow-lists.
+"""
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import List, Optional, Set
+
+logger = logging.getLogger(__name__)
+
+
+class PathValidator:
+    """
+    Validates file paths against an allowed list, with user prompting for exceptions.
+    Persists allowed paths to ~/.gaia/cache/allowed_paths.json.
+    """
+
+    def __init__(self, allowed_paths: Optional[List[str]] = None):
+        """
+        Initialize PathValidator.
+
+        Args:
+            allowed_paths: Initial list of allowed paths. Defaults to [CWD].
+        """
+        self.allowed_paths: Set[Path] = set()
+
+        # Add default allowed paths
+        if allowed_paths:
+            for p in allowed_paths:
+                self.allowed_paths.add(Path(p).resolve())
+        else:
+            self.allowed_paths.add(Path.cwd().resolve())
+
+        # Setup cache directory
+        self.cache_dir = Path.home() / ".gaia" / "cache"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.config_file = self.cache_dir / "allowed_paths.json"
+
+        # Load persisted paths
+        self._load_persisted_paths()
+
+    def _load_persisted_paths(self):
+        """Load allowed paths from cache file."""
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    for p in data.get("paths", []):
+                        try:
+                            path_obj = Path(p).resolve()
+                            if path_obj.exists():
+                                self.allowed_paths.add(path_obj)
+                        except Exception as e:
+                            logger.warning(f"Invalid path in cache {p}: {e}")
+            except Exception as e:
+                logger.error(
+                    f"Failed to load allowed paths from {self.config_file}: {e}"
+                )
+
+    def _save_persisted_path(self, path: Path):
+        """Save a new allowed path to cache file."""
+        try:
+            data = {"paths": []}
+            if self.config_file.exists():
+                try:
+                    with open(self.config_file, "r", encoding="utf-8") as f:
+                        data = json.load(f)
+                except Exception:
+                    pass  # Start fresh if corrupt
+
+            str_path = str(path)
+            if str_path not in data["paths"]:
+                data["paths"].append(str_path)
+
+                with open(self.config_file, "w", encoding="utf-8") as f:
+                    json.dump(data, f, indent=2)
+
+                logger.info(f"Persisted new allowed path: {path}")
+        except Exception as e:
+            logger.error(f"Failed to save allowed path to {self.config_file}: {e}")
+
+    def add_allowed_path(self, path: str) -> None:
+        """
+        Add a path to the allowed paths set.
+
+        Args:
+            path: Path to add to allowed paths
+        """
+        self.allowed_paths.add(Path(path).resolve())
+        logger.debug(f"Added allowed path: {path}")
+
+    def is_path_allowed(self, path: str, prompt_user: bool = True) -> bool:
+        """
+        Check if a path is allowed. If not, optionally prompt the user.
+
+        Args:
+            path: Path to check
+            prompt_user: Whether to ask user for permission if path is not allowed
+
+        Returns:
+            True if allowed, False otherwise
+        """
+        try:
+            # Resolve path using os.path.realpath to follow symlinks
+            # This prevents TOCTOU attacks by resolving at check time
+            real_path = Path(os.path.realpath(path)).resolve()
+
+            # Check if real path is within any allowed directory
+            for allowed_path in self.allowed_paths:
+                try:
+                    # is_relative_to requires Python 3.9+, use alternative for compatibility
+                    real_path.relative_to(allowed_path)
+                    return True
+                except ValueError:
+                    continue
+
+            # If we get here, path is not allowed. Prompt user?
+            if prompt_user:
+                return self._prompt_user_for_access(real_path)
+
+            return False
+
+        except Exception as e:
+            logger.error(f"Error validating path {path}: {e}")
+            return False
+
+    def _prompt_user_for_access(self, path: Path) -> bool:
+        """Prompt user to allow access to a path."""
+        print(
+            "\n⚠️  SECURITY WARNING: Agent is attempting to access a path outside allowed directories."
+        )
+        print(f"   Path: {path}")
+        print(f"   Allowed: {[str(p) for p in self.allowed_paths]}")
+
+        while True:
+            response = (
+                input("Allow this access? [y]es / [n]o / [a]lways: ").lower().strip()
+            )
+
+            if response in ["y", "yes"]:
+                # Allow for this session only (add to memory but don't persist)
+                # We add the specific file or directory to allowed paths
+                self.allowed_paths.add(path)
+                logger.info(f"User temporarily allowed access to: {path}")
+                return True
+
+            elif response in ["a", "always"]:
+                # Allow and persist
+                self.allowed_paths.add(path)
+                self._save_persisted_path(path)
+                logger.info(f"User permanently allowed access to: {path}")
+                return True
+
+            elif response in ["n", "no"]:
+                logger.warning(f"User denied access to: {path}")
+                return False
+
+            print("Please answer 'y', 'n', or 'a'.")

gaia/talk/app.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+"""
+Gaia Talk SDK Demo Application
+
+This demonstrates various ways to use the TalkSDK for integrating
+voice and text chat capabilities into your applications.
+"""
+
+import argparse
+import asyncio
+import sys
+
+from gaia.talk.sdk import SimpleTalk, TalkConfig, TalkSDK, quick_chat
+
+
+async def demo_text_chat():
+    """Demo basic text chat functionality."""
+    print("=== Text Chat Demo ===")
+
+    config = TalkConfig(
+        enable_tts=False,  # Disable TTS for text-only demo
+        show_stats=True,
+        logging_level="INFO",
+    )
+    talk = TalkSDK(config)
+
+    # Simple chat
+    print("User: Hello! Can you tell me a short joke?")
+    response = await talk.chat("Hello! Can you tell me a short joke?")
+    print(f"AI: {response.text}")
+    if response.stats:
+        print(f"Stats: {response.stats}")
+
+
+async def demo_streaming_chat():
+    """Demo streaming text chat functionality."""
+    print("\n=== Streaming Chat Demo ===")
+
+    config = TalkConfig(enable_tts=False, show_stats=True, logging_level="INFO")
+    talk = TalkSDK(config)
+
+    # Streaming chat
+    print("User: Tell me a very short story")
+    print("AI: ", end="", flush=True)
+    async for chunk in talk.chat_stream("Tell me a very short story"):
+        if not chunk.is_complete:
+            print(chunk.text, end="", flush=True)
+        else:
+            print()  # New line at the end
+            if chunk.stats:
+                print(f"Stats: {chunk.stats}")
+
+
+async def demo_voice_chat():
+    """Demo voice chat functionality."""
+    print("\n=== Voice Chat Demo ===")
+
+    config = TalkConfig(enable_tts=True, show_stats=True, logging_level="INFO")
+    talk = TalkSDK(config)
+
+    def on_voice_input(text: str):
+        print(f"You said: {text}")
+
+    print("Starting voice chat... Say 'stop' to quit or press Ctrl+C")
+    await talk.start_voice_session(on_voice_input)
+
+
+async def demo_simple_api():
+    """Demo the SimpleTalk API."""
+    print("\n=== Simple API Demo ===")
+
+    talk = SimpleTalk(enable_tts=False)
+
+    # Simple question
+    print("User: What's 2+2?")
+    response = await talk.ask("What's 2+2?")
+    print(f"AI: {response}")
+
+    # Streaming response
+    print("User: Count from 1 to 5")
+    print("AI: ", end="", flush=True)
+    async for chunk in talk.ask_stream("Count from 1 to 5"):
+        print(chunk, end="", flush=True)
+    print()  # New line
+
+
+async def demo_quick_functions():
+    """Demo convenience functions."""
+    print("\n=== Quick Functions Demo ===")
+
+    print("User: Hello! How are you?")
+    response = await quick_chat("Hello! How are you?")
+    print(f"AI: {response}")
+
+
+async def demo_configuration():
+    """Demo configuration options."""
+    print("\n=== Configuration Demo ===")
+
+    # Custom system prompt
+    config = TalkConfig(
+        system_prompt="You are a helpful assistant that always responds in a friendly, enthusiastic way!",
+        enable_tts=False,
+        show_stats=True,
+    )
+    talk = TalkSDK(config)
+
+    print("User: How are you today?")
+    response = await talk.chat("How are you today?")
+    print(f"AI: {response.text}")
+
+    # Update configuration dynamically
+    talk.update_config(system_prompt="You are now a serious, professional assistant.")
+
+    print("User: How are you today? (after config change)")
+    response = await talk.chat("How are you today?")
+    print(f"AI: {response.text}")
+
+
+def print_integration_examples():
+    """Print example code for integration."""
+    print("\n" + "=" * 60)
+    print("INTEGRATION EXAMPLES")
+    print("=" * 60)
+
+    print(
+        """
+Basic Integration:
+```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!")
+print(response.text)
+
+# Streaming chat
+async for chunk in talk.chat_stream("Tell me a story"):
+    print(chunk.text, end="", flush=True)
+```
+
+Simple Integration:
+```python
+from gaia.talk.sdk import SimpleTalk
+
+talk = SimpleTalk()
+response = await talk.ask("What's the weather?")
+print(response)
+```
+
+Voice Chat Integration:
+```python
+from gaia.talk.sdk import TalkSDK, TalkConfig
+
+config = TalkConfig(enable_tts=True)
+talk = TalkSDK(config)
+
+def on_voice_input(text):
+    print(f"User: {text}")
+
+await talk.start_voice_session(on_voice_input)
+```
+
+Quick One-off Usage:
+```python
+from gaia.talk.sdk import quick_chat
+
+response = await quick_chat("Hello!")
+print(response)
+```
+"""
+    )
+
+
+async def main():
+    """Main entry point for the Talk SDK demo application."""
+    parser = argparse.ArgumentParser(
+        description="Gaia Talk SDK Demo - Examples of voice and text chat integration",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Demo Types:
+  text      - Basic text chat demo
+  stream    - Streaming text chat demo
+  voice     - Voice chat demo with TTS/ASR
+  simple    - SimpleTalk API demo
+  quick     - Quick functions demo
+  config    - Configuration options demo
+  all       - Run all demos sequentially
+  examples  - Show integration code examples only
+        """,
+    )
+
+    parser.add_argument(
+        "demo",
+        nargs="?",
+        default="text",
+        choices=[
+            "text",
+            "stream",
+            "voice",
+            "simple",
+            "quick",
+            "config",
+            "all",
+            "examples",
+        ],
+        help="Type of demo to run (default: text)",
+    )
+
+    # Configuration options for demos
+    parser.add_argument("--system-prompt", help="Custom system prompt for the AI")
+    parser.add_argument(
+        "--no-tts", action="store_true", help="Disable text-to-speech (for voice demo)"
+    )
+    parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Enable verbose logging"
+    )
+
+    args = parser.parse_args()
+
+    # Show just examples
+    if args.demo == "examples":
+        print_integration_examples()
+        return
+
+    print("🤖 Gaia Talk SDK Demo")
+    print("=" * 50)
+
+    try:
+        if args.demo == "all":
+            # Run all demos
+            await demo_text_chat()
+            await demo_streaming_chat()
+            await demo_simple_api()
+            await demo_quick_functions()
+            await demo_configuration()
+            print_integration_examples()
+
+            # Ask user if they want to try voice demo
+            try:
+                choice = input(
+                    "\nWould you like to try the voice chat demo? (y/N): "
+                ).lower()
+                if choice.startswith("y"):
+                    await demo_voice_chat()
+            except KeyboardInterrupt:
+                print("\nSkipping voice demo...")
+
+        elif args.demo == "text":
+            await demo_text_chat()
+        elif args.demo == "stream":
+            await demo_streaming_chat()
+        elif args.demo == "voice":
+            await demo_voice_chat()
+        elif args.demo == "simple":
+            await demo_simple_api()
+        elif args.demo == "quick":
+            await demo_quick_functions()
+        elif args.demo == "config":
+            await demo_configuration()
+
+        # Always show integration examples at the end
+        if args.demo != "voice":  # Voice demo already shows examples
+            print_integration_examples()
+
+    except KeyboardInterrupt:
+        print("\n\nDemo interrupted. Goodbye!")
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        if args.verbose:
+            import traceback
+
+            traceback.print_exc()
+        sys.exit(1)
+
+    print("\n✅ Demo completed successfully!")
+    print("\nTo integrate TalkSDK into your app:")
+    print("  from gaia.talk.sdk import TalkSDK, TalkConfig")
+    print("\nFor more examples, run: python app.py examples")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())