Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

feat(backend): Add BaaS integration blocks (#10350)

Swifty2848e62f8a89
diff --git a/autogpt_platform/backend/backend/blocks/baas/__init__.py b/autogpt_platform/backend/backend/blocks/baas/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/autogpt_platform/backend/backend/blocks/baas/_api.py b/autogpt_platform/backend/backend/blocks/baas/_api.py
new file mode 100644
index 0000000000..6a53653aa3
--- /dev/null
+++ b/autogpt_platform/backend/backend/blocks/baas/_api.py
@@ -0,0 +1,205 @@
+"""
+Meeting BaaS API client module.
+All API calls centralized for consistency and maintainability.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from backend.sdk import Requests
+
+
+class MeetingBaasAPI:
+ """Client for Meeting BaaS API endpoints."""
+
+ BASE_URL = "https://api.meetingbaas.com"
+
+ def __init__(self, api_key: str):
+ """Initialize API client with authentication key."""
+ self.api_key = api_key
+ self.headers = {"x-meeting-baas-api-key": api_key}
+ self.requests = Requests()
+
+ # Bot Management Endpoints
+
+ async def join_meeting(
+ self,
+ bot_name: str,
+ meeting_url: str,
+ reserved: bool = False,
+ bot_image: Optional[str] = None,
+ entry_message: Optional[str] = None,
+ start_time: Optional[int] = None,
+ speech_to_text: Optional[Dict[str, Any]] = None,
+ webhook_url: Optional[str] = None,
+ automatic_leave: Optional[Dict[str, Any]] = None,
+ extra: Optional[Dict[str, Any]] = None,
+ recording_mode: str = "speaker_view",
+ streaming: Optional[Dict[str, Any]] = None,
+ deduplication_key: Optional[str] = None,
+ zoom_sdk_id: Optional[str] = None,
+ zoom_sdk_pwd: Optional[str] = None,
+ ) -> Dict[str, Any]:
+ """
+ Deploy a bot to join and record a meeting.
+
+ POST /bots
+ """
+ body = {
+ "bot_name": bot_name,
+ "meeting_url": meeting_url,
+ "reserved": reserved,
+ "recording_mode": recording_mode,
+ }
+
+ # Add optional fields if provided
+ if bot_image is not None:
+ body["bot_image"] = bot_image
+ if entry_message is not None:
+ body["entry_message"] = entry_message
+ if start_time is not None:
+ body["start_time"] = start_time
+ if speech_to_text is not None:
+ body["speech_to_text"] = speech_to_text
+ if webhook_url is not None:
+ body["webhook_url"] = webhook_url
+ if automatic_leave is not None:
+ body["automatic_leave"] = automatic_leave
+ if extra is not None:
+ body["extra"] = extra
+ if streaming is not None:
+ body["streaming"] = streaming
+ if deduplication_key is not None:
+ body["deduplication_key"] = deduplication_key
+ if zoom_sdk_id is not None:
+ body["zoom_sdk_id"] = zoom_sdk_id
+ if zoom_sdk_pwd is not None:
+ body["zoom_sdk_pwd"] = zoom_sdk_pwd
+
+ response = await self.requests.post(
+ f"{self.BASE_URL}/bots",
+ headers=self.headers,
+ json=body,
+ )
+ return response.json()
+
+ async def leave_meeting(self, bot_id: str) -> bool:
+ """
+ Remove a bot from an ongoing meeting.
+
+ DELETE /bots/{uuid}
+ """
+ response = await self.requests.delete(
+ f"{self.BASE_URL}/bots/{bot_id}",
+ headers=self.headers,
+ )
+ return response.status in [200, 204]
+
+ async def retranscribe(
+ self,
+ bot_uuid: str,
+ speech_to_text: Optional[Dict[str, Any]] = None,
+ webhook_url: Optional[str] = None,
+ ) -> Dict[str, Any]:
+ """
+ Re-run transcription on a bot's audio.
+
+ POST /bots/retranscribe
+ """
+ body: Dict[str, Any] = {"bot_uuid": bot_uuid}
+
+ if speech_to_text is not None:
+ body["speech_to_text"] = speech_to_text
+ if webhook_url is not None:
+ body["webhook_url"] = webhook_url
+
+ response = await self.requests.post(
+ f"{self.BASE_URL}/bots/retranscribe",
+ headers=self.headers,
+ json=body,
+ )
+
+ if response.status == 202:
+ return {"accepted": True}
+ return response.json()
+
+ # Data Retrieval Endpoints
+
+ async def get_meeting_data(
+ self, bot_id: str, include_transcripts: bool = True
+ ) -> Dict[str, Any]:
+ """
+ Retrieve meeting data including recording and transcripts.
+
+ GET /bots/meeting_data
+ """
+ params = {
+ "bot_id": bot_id,
+ "include_transcripts": str(include_transcripts).lower(),
+ }
+
+ response = await self.requests.get(
+ f"{self.BASE_URL}/bots/meeting_data",
+ headers=self.headers,
+ params=params,
+ )
+ return response.json()
+
+ async def get_screenshots(self, bot_id: str) -> List[Dict[str, Any]]:
+ """
+ Retrieve screenshots captured during a meeting.
+
+ GET /bots/{uuid}/screenshots
+ """
+ response = await self.requests.get(
+ f"{self.BASE_URL}/bots/{bot_id}/screenshots",
+ headers=self.headers,
+ )
+ result = response.json()
+ # Ensure we return a list
+ if isinstance(result, list):
+ return result
+ return []
+
+ async def delete_data(self, bot_id: str) -> bool:
+ """
+ Delete a bot's recorded data.
+
+ POST /bots/{uuid}/delete_data
+ """
+ response = await self.requests.post(
+ f"{self.BASE_URL}/bots/{bot_id}/delete_data",
+ headers=self.headers,
+ )
+ return response.status == 200
+
+ async def list_bots_with_metadata(
+ self,
+ limit: Optional[int] = None,
+ offset: Optional[int] = None,
+ sort_by: Optional[str] = None,
+ sort_order: Optional[str] = None,
+ filter_by: Optional[Dict[str, Any]] = None,
+ ) -> Dict[str, Any]:
+ """
+ List bots with metadata including IDs, names, and meeting details.
+
+ GET /bots/bots_with_metadata
+ """
+ params = {}
+ if limit is not None:
+ params["limit"] = limit
+ if offset is not None:
+ params["offset"] = offset
+ if sort_by is not None:
+ params["sort_by"] = sort_by
+ if sort_order is not None:
+ params["sort_order"] = sort_order
+ if filter_by is not None:
+ params.update(filter_by)
+
+ response = await self.requests.get(
+ f"{self.BASE_URL}/bots/bots_with_metadata",
+ headers=self.headers,
+ params=params,
+ )
+ return response.json()
diff --git a/autogpt_platform/backend/backend/blocks/baas/_config.py b/autogpt_platform/backend/backend/blocks/baas/_config.py
new file mode 100644
index 0000000000..c6ae3e68f5
--- /dev/null
+++ b/autogpt_platform/backend/backend/blocks/baas/_config.py
@@ -0,0 +1,13 @@
+"""
+Shared configuration for all Meeting BaaS blocks using the SDK pattern.
+"""
+
+from backend.sdk import BlockCostType, ProviderBuilder
+
+# Configure the Meeting BaaS provider with API key authentication
+baas = (
+ ProviderBuilder("baas")
+ .with_api_key("MEETING_BAAS_API_KEY", "Meeting BaaS API Key")
+ .with_base_cost(5, BlockCostType.RUN) # Higher cost for meeting recording service
+ .build()
+)
diff --git a/autogpt_platform/backend/backend/blocks/baas/bots.py b/autogpt_platform/backend/backend/blocks/baas/bots.py
new file mode 100644
index 0000000000..da8400bb2c
--- /dev/null
+++ b/autogpt_platform/backend/backend/blocks/baas/bots.py
@@ -0,0 +1,217 @@
+"""
+Meeting BaaS bot (recording) blocks.
+"""
+
+from typing import Optional
+
+from backend.sdk import (
+ APIKeyCredentials,
+ Block,
+ BlockCategory,
+ BlockOutput,
+ BlockSchema,
+ CredentialsMetaInput,
+ SchemaField,
+)
+
+from ._api import MeetingBaasAPI
+from ._config import baas
+
+
+class BaasBotJoinMeetingBlock(Block):
+ """
+ Deploy a bot immediately or at a scheduled start_time to join and record a meeting.
+ """
+
+ class Input(BlockSchema):
+ credentials: CredentialsMetaInput = baas.credentials_field(
+ description="Meeting BaaS API credentials"
+ )
+ meeting_url: str = SchemaField(
+ description="The URL of the meeting the bot should join"
+ )
+ bot_name: str = SchemaField(
+ description="Display name for the bot in the meeting"
+ )
+ bot_image: str = SchemaField(
+ description="URL to an image for the bot's avatar (16:9 ratio recommended)",
+ default="",
+ )
+ entry_message: str = SchemaField(
+ description="Chat message the bot will post upon entry", default=""
+ )
+ reserved: bool = SchemaField(
+ description="Use a reserved bot slot (joins 4 min before meeting)",
+ default=False,
+ )
+ start_time: Optional[int] = SchemaField(
+ description="Unix timestamp (ms) when bot should join", default=None
+ )
+ webhook_url: str | None = SchemaField(
+ description="URL to receive webhook events for this bot", default=None
+ )
+ timeouts: dict = SchemaField(
+ description="Automatic leave timeouts configuration", default={}
+ )
+ extra: dict = SchemaField(
+ description="Custom metadata to attach to the bot", default={}
+ )
+
+ class Output(BlockSchema):
+ bot_id: str = SchemaField(description="UUID of the deployed bot")
+ join_response: dict = SchemaField(
+ description="Full response from join operation"
+ )
+
+ def __init__(self):
+ super().__init__(
+ id="377d1a6a-a99b-46cf-9af3-1d1b12758e04",
+ description="Deploy a bot to join and record a meeting",
+ categories={BlockCategory.COMMUNICATION},
+ input_schema=self.Input,
+ output_schema=self.Output,
+ )
+
+ async def run(
+ self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+ ) -> BlockOutput:
+ api_key = credentials.api_key.get_secret_value()
+ api = MeetingBaasAPI(api_key)
+
+ # Call API with all parameters
+ data = await api.join_meeting(
+ bot_name=input_data.bot_name,
+ meeting_url=input_data.meeting_url,
+ reserved=input_data.reserved,
+ bot_image=input_data.bot_image if input_data.bot_image else None,
+ entry_message=(
+ input_data.entry_message if input_data.entry_message else None
+ ),
+ start_time=input_data.start_time,
+ speech_to_text={"provider": "Default"},
+ webhook_url=input_data.webhook_url if input_data.webhook_url else None,
+ automatic_leave=input_data.timeouts if input_data.timeouts else None,
+ extra=input_data.extra if input_data.extra else None,
+ )
+
+ yield "bot_id", data.get("bot_id", "")
+ yield "join_response", data
+
+
+class BaasBotLeaveMeetingBlock(Block):
+ """
+ Force the bot to exit the call.
+ """
+
+ class Input(BlockSchema):
+ credentials: CredentialsMetaInput = baas.credentials_field(
+ description="Meeting BaaS API credentials"
+ )
+ bot_id: str = SchemaField(description="UUID of the bot to remove from meeting")
+
+ class Output(BlockSchema):
+ left: bool = SchemaField(description="Whether the bot successfully left")
+
+ def __init__(self):
+ super().__init__(
+ id="bf77d128-8b25-4280-b5c7-2d553ba7e482",
+ description="Remove a bot from an ongoing meeting",
+ categories={BlockCategory.COMMUNICATION},
+ input_schema=self.Input,
+ output_schema=self.Output,
+ )
+
+ async def run(
+ self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+ ) -> BlockOutput:
+ api_key = credentials.api_key.get_secret_value()
+ api = MeetingBaasAPI(api_key)
+
+ # Leave meeting
+ left = await api.leave_meeting(input_data.bot_id)
+
+ yield "left", left
+
+
+class BaasBotFetchMeetingDataBlock(Block):
+ """
+ Pull MP4 URL, transcript & metadata for a completed meeting.
+ """
+
+ class Input(BlockSchema):
+ credentials: CredentialsMetaInput = baas.credentials_field(
+ description="Meeting BaaS API credentials"
+ )
+ bot_id: str = SchemaField(description="UUID of the bot whose data to fetch")
+ include_transcripts: bool = SchemaField(
+ description="Include transcript data in response", default=True
+ )
+
+ class Output(BlockSchema):
+ mp4_url: str = SchemaField(
+ description="URL to download the meeting recording (time-limited)"
+ )
+ transcript: list = SchemaField(description="Meeting transcript data")
+ metadata: dict = SchemaField(description="Meeting metadata and bot information")
+
+ def __init__(self):
+ super().__init__(
+ id="ea7c1309-303c-4da1-893f-89c0e9d64e78",
+ description="Retrieve recorded meeting data",
+ categories={BlockCategory.DATA},
+ input_schema=self.Input,
+ output_schema=self.Output,
+ )
+
+ async def run(
+ self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+ ) -> BlockOutput:
+ api_key = credentials.api_key.get_secret_value()
+ api = MeetingBaasAPI(api_key)
+
+ # Fetch meeting data
+ data = await api.get_meeting_data(
+ bot_id=input_data.bot_id,
+ include_transcripts=input_data.include_transcripts,
+ )
+
+ yield "mp4_url", data.get("mp4", "")
+ yield "transcript", data.get("bot_data", {}).get("transcripts", [])
+ yield "metadata", data.get("bot_data", {}).get("bot", {})
+
+
+class BaasBotDeleteRecordingBlock(Block):
+ """
+ Purge MP4 + transcript data for privacy or storage management.
+ """
+
+ class Input(BlockSchema):
+ credentials: CredentialsMetaInput = baas.credentials_field(
+ description="Meeting BaaS API credentials"
+ )
+ bot_id: str = SchemaField(description="UUID of the bot whose data to delete")
+
+ class Output(BlockSchema):
+ deleted: bool = SchemaField(
+ description="Whether the data was successfully deleted"
+ )
+
+ def __init__(self):
+ super().__init__(
+ id="bf8d1aa6-42d8-4944-b6bd-6bac554c0d3b",
+ description="Permanently delete a meeting's recorded data",
+ categories={BlockCategory.DATA},
+ input_schema=self.Input,
+ output_schema=self.Output,
+ )
+
+ async def run(
+ self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+ ) -> BlockOutput:
+ api_key = credentials.api_key.get_secret_value()
+ api = MeetingBaasAPI(api_key)
+
+ # Delete recording data
+ deleted = await api.delete_data(input_data.bot_id)
+
+ yield "deleted", deleted