fix(examples): update examples for v5.5 regenerated SDK types and methods

Update examples to use renamed methods (send_settings, send_media,
send_text, send_flush, send_close) and new response shapes
(stt/tts model split, nested usage results, wrapped request response).

Author: lukeocodes

examples/09-voice-agent.py

@@ -12,18 +12,18 @@
 
 from deepgram import DeepgramClient
 from deepgram.agent.v1.types import (
-    AgentV1Agent,
-    AgentV1AudioConfig,
-    AgentV1AudioInput,
-    AgentV1DeepgramSpeakProvider,
-    AgentV1Listen,
-    AgentV1ListenProvider,
-    AgentV1OpenAiThinkProvider,
     AgentV1Settings,
-    AgentV1SpeakProviderConfig,
-    AgentV1Think,
+    AgentV1SettingsAgent,
+    AgentV1SettingsAgentListen,
+    AgentV1SettingsAgentListenProvider_V1,
+    AgentV1SettingsAudio,
+    AgentV1SettingsAudioInput,
 )
 from deepgram.core.events import EventType
+from deepgram.types.speak_settings_v1 import SpeakSettingsV1
+from deepgram.types.speak_settings_v1provider import SpeakSettingsV1Provider_Deepgram
+from deepgram.types.think_settings_v1 import ThinkSettingsV1
+from deepgram.types.think_settings_v1provider import ThinkSettingsV1Provider_OpenAi
 
 AgentV1SocketClientResponse = Union[str, bytes]
 
@@ -33,30 +33,29 @@
     with client.agent.v1.connect() as agent:
         # Configure the agent settings
         settings = AgentV1Settings(
-            audio=AgentV1AudioConfig(
-                input=AgentV1AudioInput(
+            audio=AgentV1SettingsAudio(
+                input=AgentV1SettingsAudioInput(
                     encoding="linear16",
-                    sample_rate=44100,
+                    sample_rate=24000,
                 )
             ),
-            agent=AgentV1Agent(
-                listen=AgentV1Listen(
-                    provider=AgentV1ListenProvider(
+            agent=AgentV1SettingsAgent(
+                listen=AgentV1SettingsAgentListen(
+                    provider=AgentV1SettingsAgentListenProvider_V1(
                         type="deepgram",
                         model="nova-3",
-                        smart_format=True,
                     )
                 ),
-                think=AgentV1Think(
-                    provider=AgentV1OpenAiThinkProvider(
+                think=ThinkSettingsV1(
+                    provider=ThinkSettingsV1Provider_OpenAi(
                         type="open_ai",
                         model="gpt-4o-mini",
                         temperature=0.7,
                     ),
                     prompt="You are a helpful AI assistant.",
                 ),
-                speak=AgentV1SpeakProviderConfig(
-                    provider=AgentV1DeepgramSpeakProvider(
+                speak=SpeakSettingsV1(
+                    provider=SpeakSettingsV1Provider_Deepgram(
                         type="deepgram",
                         model="aura-2-asteria-en",
                     )
@@ -65,7 +64,7 @@
         )
 
         print("Sending agent settings...")
-        agent.send_agent_v_1_settings(settings)
+        agent.send_settings(settings)
 
         def on_message(message: AgentV1SocketClientResponse) -> None:
             if isinstance(message, bytes):
@@ -84,15 +83,15 @@ def on_message(message: AgentV1SocketClientResponse) -> None:
         # In production, you would send audio from your microphone or audio source:
         # with open("audio.wav", "rb") as audio_file:
         #     audio_data = audio_file.read()
-        #     agent.send_agent_v_1_media(audio_data)
+        #     agent.send_media(audio_data)
 
         agent.start_listening()
 
     # For async version:
     # from deepgram import AsyncDeepgramClient
     # async with client.agent.v1.connect() as agent:
     #     # ... same configuration ...
-    #     await agent.send_agent_v_1_settings(settings)
+    #     await agent.send_settings(settings)
     #     await agent.start_listening()
 
 except Exception as e:

examples/11-text-to-speech-streaming.py

@@ -12,7 +12,7 @@
 
 from deepgram import DeepgramClient
 from deepgram.core.events import EventType
-from deepgram.speak.v1.types import SpeakV1Close, SpeakV1Flush, SpeakV1Text
+from deepgram.speak.v1.types import SpeakV1Text
 
 SpeakV1SocketClientResponse = Union[str, bytes]
 
@@ -40,15 +40,13 @@ def on_message(message: SpeakV1SocketClientResponse) -> None:
         # Note: start_listening() blocks, so send all messages first
         # For better control with bidirectional communication, use the async version
         text_message = SpeakV1Text(text="Hello, this is a text to speech example.")
-        connection.send_speak_v_1_text(text_message)
+        connection.send_text(text_message)
 
         # Flush to ensure all text is processed
-        flush_message = SpeakV1Flush()
-        connection.send_speak_v_1_flush(flush_message)
+        connection.send_flush()
 
         # Close the connection when done
-        close_message = SpeakV1Close()
-        connection.send_speak_v_1_close(close_message)
+        connection.send_close()
 
         # Start listening - this blocks until the connection closes
         # All messages should be sent before calling this in sync mode
@@ -58,9 +56,9 @@ def on_message(message: SpeakV1SocketClientResponse) -> None:
     # from deepgram import AsyncDeepgramClient
     # async with client.speak.v1.connect(...) as connection:
     #     listen_task = asyncio.create_task(connection.start_listening())
-    #     await connection.send_speak_v_1_text(SpeakV1Text(text="..."))
-    #     await connection.send_speak_v_1_flush(SpeakV1Flush())
-    #     await connection.send_speak_v_1_close(SpeakV1Close())
+    #     await connection.send_text(SpeakV1Text(text="..."))
+    #     await connection.send_flush()
+    #     await connection.send_close()
     #     await listen_task
 
 except Exception as e:

examples/12-text-intelligence.py

@@ -24,13 +24,14 @@
     )
 
     print("Analysis received:")
-    print(f"Sentiment: {response.sentiment}")
-    if response.summary:
-        print(f"Summary: {response.summary}")
-    if response.topics:
-        print(f"Topics: {response.topics}")
-    if response.intents:
-        print(f"Intents: {response.intents}")
+    if response.results.sentiments:
+        print(f"Sentiment: {response.results.sentiments.average}")
+    if response.results.summary:
+        print(f"Summary: {response.results.summary.text}")
+    if response.results.topics:
+        print(f"Topics: {response.results.topics.segments}")
+    if response.results.intents:
+        print(f"Intents: {response.results.intents.segments}")
 
     # For async version:
     # from deepgram import AsyncDeepgramClient

examples/17-management-usage.py

@@ -25,18 +25,24 @@
     # Get usage summary
     print("\nGetting usage summary...")
     usage = client.manage.v1.projects.usage.get(project_id=project_id)
-    print(f"Total requests: {usage.total_requests}")
-    print(f"Total hours: {usage.total_hours}")
+    print(f"Start: {usage.start}")
+    print(f"End: {usage.end}")
+    if usage.resolution:
+        print(f"Resolution: {usage.resolution.amount} {usage.resolution.units}")
 
     # Get usage breakdown
     print("\nGetting usage breakdown...")
     breakdown = client.manage.v1.projects.usage.breakdown.get(project_id=project_id)
-    print(f"Breakdown entries: {len(breakdown.entries) if breakdown.entries else 0}")
+    print(f"Breakdown results: {len(breakdown.results) if breakdown.results else 0}")
+    if breakdown.results:
+        for result in breakdown.results:
+            print(f"  Requests: {result.requests}, Hours: {result.hours}")
 
     # Get usage fields
     print("\nGetting usage fields...")
     fields = client.manage.v1.projects.usage.fields.list(project_id=project_id)
-    print(f"Available fields: {len(fields.fields) if fields.fields else 0}")
+    print(f"Available models: {len(fields.models) if fields.models else 0}")
+    print(f"Available features: {len(fields.features) if fields.features else 0}")
 
     # List usage requests
     print("\nListing usage requests...")
@@ -48,8 +54,9 @@
         request_id = requests.requests[0].request_id
         print(f"\nGetting request details: {request_id}")
         request = client.manage.v1.projects.requests.get(project_id=project_id, request_id=request_id)
-        print(f"Request method: {request.method}")
-        print(f"Request endpoint: {request.endpoint}")
+        if request.request:
+            print(f"Request path: {request.request.path}")
+            print(f"Request code: {request.request.code}")
 
     # For async version:
     # from deepgram import AsyncDeepgramClient

examples/19-management-models.py

@@ -16,39 +16,55 @@
     # List all public models
     print("Listing all public models...")
     models = client.manage.v1.models.list()
-    print(f"Found {len(models.models) if models.models else 0} models")
 
-    for model in models.models or []:
-        print(f"  - {model.name} (ID: {model.model_id})")
-        if hasattr(model, "language") and model.language:
-            print(f"    Language: {model.language}")
+    stt_count = len(models.stt) if models.stt else 0
+    tts_count = len(models.tts) if models.tts else 0
+    print(f"Found {stt_count} STT models and {tts_count} TTS models")
+
+    print("\nSTT Models:")
+    for model in models.stt or []:
+        print(f"  - {model.name} (UUID: {model.uuid_})")
+        if model.languages:
+            print(f"    Languages: {', '.join(model.languages)}")
+
+    print("\nTTS Models:")
+    for model in models.tts or []:
+        print(f"  - {model.name} (UUID: {model.uuid_})")
+        if model.languages:
+            print(f"    Languages: {', '.join(model.languages)}")
 
     # List including outdated models
     print("\nListing all models (including outdated)...")
     all_models = client.manage.v1.models.list(include_outdated=True)
-    print(f"Found {len(all_models.models) if all_models.models else 0} total models")
+    all_stt = len(all_models.stt) if all_models.stt else 0
+    all_tts = len(all_models.tts) if all_models.tts else 0
+    print(f"Found {all_stt} STT and {all_tts} TTS total models")
 
     # Get a specific model
-    if models.models:
-        model_id = models.models[0].model_id
-        print(f"\nGetting model details: {model_id}")
-        model = client.manage.v1.models.get(model_id=model_id)
+    if models.stt:
+        model_uuid = models.stt[0].uuid_
+        print(f"\nGetting model details: {model_uuid}")
+        model = client.manage.v1.models.get(model_id=model_uuid)
         print(f"Model name: {model.name}")
-        if hasattr(model, "language") and model.language:
-            print(f"Language: {model.language}")
+        if model.languages:
+            print(f"Languages: {', '.join(model.languages)}")
 
     # Get project-specific models
     projects = client.manage.v1.projects.list()
     if projects.projects:
         project_id = projects.projects[0].project_id
         print(f"\nGetting models for project: {project_id}")
         project_models = client.manage.v1.projects.models.list(project_id=project_id)
-        print(f"Found {len(project_models.models) if project_models.models else 0} project models")
+        p_stt = len(project_models.stt) if project_models.stt else 0
+        p_tts = len(project_models.tts) if project_models.tts else 0
+        print(f"Found {p_stt} STT and {p_tts} TTS project models")
 
-        if project_models.models:
-            project_model_id = project_models.models[0].model_id
-            print(f"\nGetting project model details: {project_model_id}")
-            project_model = client.manage.v1.projects.models.get(project_id=project_id, model_id=project_model_id)
+        if project_models.stt:
+            project_model_uuid = project_models.stt[0].uuid_
+            print(f"\nGetting project model details: {project_model_uuid}")
+            project_model = client.manage.v1.projects.models.get(
+                project_id=project_id, model_id=project_model_uuid
+            )
             print(f"Model name: {project_model.name}")
 
     # For async version:

examples/26-transcription-live-websocket-v2.py

@@ -24,7 +24,7 @@
 client = DeepgramClient()
 
 try:
-    with client.listen.v2.connect(model="flux-general-en", encoding="linear16", sample_rate="16000") as connection:
+    with client.listen.v2.connect(model="flux-general-en", encoding="linear16", sample_rate=16000) as connection:
 
         def on_message(message: ListenV2SocketClientResponse) -> None:
             msg_type = getattr(message, "type", "Unknown")
@@ -42,7 +42,7 @@ def on_message(message: ListenV2SocketClientResponse) -> None:
         connection.on(EventType.ERROR, lambda error: print(f"Error: {error}"))
 
         # Start listening - this blocks until the connection closes
-        # In production, you would send audio data here using connection.send_listen_v_2_media()
+        # In production, you would send audio data here using connection.send_media()
         connection.start_listening()
 
     # For async version: