feat: add RTStream export and improve capture API

- Add export() method to RTStream for exporting recordings as video/audio assets
- Add RTStreamExportResult class to hold export metadata
- Add store parameter to create_rtstream() for enabling recording storage
- Rename capture methods for consistency:
  - start_capture_session -> start_session
  - stop_capture -> stop_session

Author: lalit-videodb

videodb/_constants.py

@@ -109,6 +109,7 @@ class ApiPath:
     session = "session"
     token = "token"
     websocket = "websocket"
+    export = "export"
 
 
 class Status:

videodb/capture.py

@@ -356,7 +356,7 @@ async def list_channels(self) -> Channels:
 
         return Channels(mics=mics, displays=displays, system_audio=system_audio)
 
-    async def start_capture_session(
+    async def start_session(
         self,
         capture_session_id: str,
         channels: List[Channel],
@@ -385,7 +385,7 @@ async def start_capture_session(
 
         await self._send_command("startRecording", payload)
 
-    async def stop_capture(self) -> None:
+    async def stop_session(self) -> None:
         """Stop the current recording session."""
         if not self._session_id:
             raise RuntimeError("No active capture session to stop.")

videodb/collection.py

@@ -174,6 +174,7 @@ def connect_rtstream(
         name: str,
         media_types: List[str] = None,
         sample_rate: int = None,
+        store: bool = None,
         enable_transcript: bool = None,
         ws_connection_id: str = None,
     ) -> RTStream:
@@ -184,6 +185,8 @@ def connect_rtstream(
         :param list media_types: List of media types to capture (default: [MediaType.video]).
             Valid values: :attr:`MediaType.audio`, :attr:`MediaType.video`
         :param int sample_rate: Sample rate of the rtstream (optional, server default: 30)
+        :param bool store: Enable recording storage (optional, default: False).
+            When True, the stream recording is stored and can be exported via :meth:`RTStream.export`.
         :param bool enable_transcript: Enable real-time transcription (optional)
         :param str ws_connection_id: WebSocket connection ID for receiving events (optional)
         :return: :class:`RTStream <RTStream>` object
@@ -206,6 +209,8 @@ def connect_rtstream(
         }
         if sample_rate is not None:
             data["sample_rate"] = sample_rate
+        if store is not None:
+            data["store"] = store
         if enable_transcript is not None:
             data["enable_transcript"] = enable_transcript
         if ws_connection_id is not None:

videodb/rtstream.py

@@ -39,6 +39,39 @@ def get_shots(self) -> List["RTStreamShot"]:
         return self.shots
 
 
+class RTStreamExportResult:
+    """Result of exporting an RTStream recording.
+
+    :ivar str video_id: ID of the exported video or audio asset
+    :ivar str stream_url: URL to stream the exported asset (may be None for audio)
+    :ivar str player_url: URL to play the exported asset in a player (may be None for audio)
+    :ivar str name: Name of the exported recording
+    :ivar float duration: Duration of the exported recording in seconds (may be None on idempotent calls)
+    """
+
+    def __init__(
+        self,
+        video_id: str,
+        stream_url: Optional[str] = None,
+        player_url: Optional[str] = None,
+        name: Optional[str] = None,
+        duration: Optional[float] = None,
+    ) -> None:
+        self.video_id = video_id
+        self.stream_url = stream_url
+        self.player_url = player_url
+        self.name = name
+        self.duration = duration
+
+    def __repr__(self) -> str:
+        return (
+            f"RTStreamExportResult("
+            f"video_id={self.video_id}, "
+            f"name={self.name}, "
+            f"duration={self.duration})"
+        )
+
+
 class RTStreamShot:
     """RTStreamShot class for rtstream search results
 
@@ -326,6 +359,32 @@ def stop(self):
         )
         self.status = "stopped"
 
+    def export(self, name: Optional[str] = None) -> "RTStreamExportResult":
+        """Export the latest completed recording as a video or audio asset.
+
+        The stream must be stopped before exporting. The call is idempotent:
+        calling it again returns the same asset without re-ingesting.
+
+        :param str name: Name for the exported asset (optional, defaults to "{stream_name} - Recording")
+        :return: Export result with the asset ID and metadata
+        :rtype: :class:`RTStreamExportResult`
+        """
+        data = {}
+        if name is not None:
+            data["name"] = name
+
+        export_data = self._connection.post(
+            path=f"{ApiPath.rtstream}/{self.id}/{ApiPath.export}",
+            data=data,
+        )
+        return RTStreamExportResult(
+            video_id=export_data.get("video_id"),
+            stream_url=export_data.get("stream_url"),
+            player_url=export_data.get("player_url"),
+            name=export_data.get("name"),
+            duration=export_data.get("duration"),
+        )
+
     def start_transcript(
         self, ws_connection_id: Optional[str] = None, engine: str = "assemblyai"
     ) -> dict: