SwisperStudio SDK Upgrade to v0.5.1¶

- swisper-studio-sdk = "0.5.0"
+ swisper-studio-sdk = "0.5.1"

# Initialize SwisperStudio observability (SDK v0.5.0)
# SDK installed from GitHub Releases as proper pip package
if settings.SWISPER_STUDIO_ENABLED:
    try:
        from swisper_studio_sdk import initialize_redis_publisher, wrap_llm_adapter

        # Initialize Redis Streams publisher for observability
        await initialize_redis_publisher(
            redis_url=settings.SWISPER_STUDIO_REDIS_URL,
            stream_name=settings.SWISPER_STUDIO_STREAM_NAME,
            project_id=settings.SWISPER_STUDIO_PROJECT_ID,
            verify_consumer=True,  # Check if SwisperStudio consumer is running
        )
        logger.info("✅ SwisperStudio observability initialized (Redis Streams)")
        logger.info(f"   Redis: {settings.SWISPER_STUDIO_REDIS_URL}")
        logger.info(f"   Stream: {settings.SWISPER_STUDIO_STREAM_NAME}")
        logger.info(f"   Project ID: {settings.SWISPER_STUDIO_PROJECT_ID}")

        # Enable LLM prompt capture (includes streaming support)
        try:
            wrap_llm_adapter()
            logger.info("✅ LLM prompt capture enabled (structured + streaming)")
        except Exception as e:
            logger.warning(f"⚠️ LLM prompt capture disabled: {e}")
            logger.warning("   State capture will still work")

    except ImportError:
        logger.warning("⚠️ SwisperStudio SDK not installed - observability disabled")
        logger.warning("   Install with: pip install swisper-studio-sdk==0.5.0")
    except Exception as e:
        logger.warning(f"⚠️ SwisperStudio observability initialization failed: {e}")
        logger.warning(
            "   Continuing without observability - events will queue in Redis"
        )

# Initialize SwisperStudio observability (SDK v0.5.1)
# SDK v0.5.1: ROBUST - safe_initialize() NEVER blocks or crashes Swisper
if settings.SWISPER_STUDIO_ENABLED:
    try:
        from swisper_studio_sdk import safe_initialize, wrap_llm_adapter

        # safe_initialize() is completely safe:
        # - NEVER raises exceptions
        # - NEVER blocks indefinitely (has timeouts)
        # - Returns status dict instead of raising
        # - If Redis unavailable, tracing is silently disabled
        status = await safe_initialize(
            redis_url=settings.SWISPER_STUDIO_REDIS_URL,
            project_id=settings.SWISPER_STUDIO_PROJECT_ID,
            stream_name=settings.SWISPER_STUDIO_STREAM_NAME,
            verify_consumer=True,
            connection_timeout=5.0,  # Max 5 seconds to connect
        )

        if status.get("initialized"):
            logger.info("✅ SwisperStudio observability initialized (Redis Streams)")
            logger.info(f"   Redis: {settings.SWISPER_STUDIO_REDIS_URL}")
            logger.info(f"   Project ID: {settings.SWISPER_STUDIO_PROJECT_ID}")

            # Enable LLM prompt capture (includes streaming support)
            try:
                wrap_llm_adapter()
                logger.info("✅ LLM prompt capture enabled (structured + streaming)")
            except Exception as e:
                logger.debug(f"LLM prompt capture skipped: {e}")
        else:
            logger.warning("⚠️ SwisperStudio tracing disabled (Swisper continues normally)")
            if not status.get("redis"):
                logger.warning("   Reason: Redis connection failed or timed out")
            elif not status.get("write"):
                logger.warning("   Reason: Redis write permission denied")

    except ImportError:
        logger.warning("⚠️ SwisperStudio SDK not installed - observability disabled")
        logger.warning("   Install with: pip install swisper-studio-sdk==0.5.1")
    except Exception as e:
        # This should NEVER happen with safe_initialize, but just in case
        logger.warning(f"⚠️ SwisperStudio unexpected error: {e}")
        logger.warning("   Continuing without observability")

status = await safe_initialize(
    redis_url: str,              # Required: Redis URL
    project_id: str,             # Required: Project ID
    stream_name: str = "...",    # Optional: Stream name
    verify_consumer: bool = True, # Optional: Check consumer
    connection_timeout: float = 5.0,  # Optional: Max connect time
)

# Returns dict (NEVER raises):
{
    "enabled": True,       # Was initialization attempted
    "redis": True/False,   # Redis connectivity OK
    "write": True/False,   # Write permission OK
    "consumer": True/False, # Consumer detected
    "initialized": True/False,  # Overall success
}

# Test with WRONG Redis URL (simulates misconfiguration)
python -c "
import asyncio
from swisper_studio_sdk import safe_initialize

async def test():
    status = await safe_initialize(
        redis_url='redis://nonexistent:6379',  # Wrong URL
        project_id='test',
        connection_timeout=3.0
    )
    print(f'Status: {status}')
    print(f'Initialized: {status[\"initialized\"]}')  # Should be False
    print('✅ Swisper would continue normally!')

asyncio.run(test())
"

⚠️ Redis connection timed out after 3.0s
   Tracing will be DISABLED (Swisper continues normally)
Status: {'enabled': True, 'redis': False, 'write': False, 'consumer': False, 'initialized': False}
Initialized: False
✅ Swisper would continue normally!