dv-pipecat-ai 0.0.82.dev776__tar.gz → 0.0.82.dev807__tar.gz

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/.github/workflows/github.yml

@@ -251,11 +251,17 @@ jobs:
           echo "❌ ADMIN_API_KEY not found in SECRETS_JSON"
           exit 1
         fi
+        STAGE_CALLING_BACKEND_URL=$(echo "$SECRETS_JSON" | jq -r '.CALLING_BACKEND_URL // empty')
+        if [ -z "$STAGE_CALLING_BACKEND_URL" ]; then
+          echo "❌ CALLING_BACKEND_URL not found in SECRETS_JSON"
+          exit 1
+        fi
         helm upgrade --install $HELM_RELEASE_NAME ./k8s/dv-pipecat \
           -f ./k8s/dv-pipecat/values-stage.yaml \
           --set image.repository=$REGION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE_NAME \
           --set image.tag=$GITHUB_SHA \
           --set ADMIN_API_KEY="${STAGE_ADMIN_API_KEY}" \
+          --set CALLING_BACKEND_URL="${STAGE_CALLING_BACKEND_URL}" \
           --namespace default
 
     # 2) **ONLY** when branch is dv-main: deploy/update the CANARY release
@@ -267,6 +273,11 @@ jobs:
           echo "❌ ADMIN_API_KEY not found in SECRETS_JSON"
           exit 1
         fi
+        PROD_CALLING_BACKEND_URL=$(echo "$SECRETS_JSON" | jq -r '.CALLING_BACKEND_URL // empty')
+        if [ -z "$PROD_CALLING_BACKEND_URL" ]; then
+          echo "❌ CALLING_BACKEND_URL not found in SECRETS_JSON"
+          exit 1
+        fi
         echo "🚀 Deploying canary service..."
         helm upgrade --install ${HELM_RELEASE_NAME}-canary ./k8s/dv-pipecat \
           -f ./k8s/dv-pipecat/values-prod.yaml \
@@ -274,6 +285,7 @@ jobs:
           --set image.repository=$REGION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE_NAME \
           --set image.tag=$GITHUB_SHA \
           --set ADMIN_API_KEY="${PROD_ADMIN_API_KEY}" \
+          --set CALLING_BACKEND_URL="${PROD_CALLING_BACKEND_URL}" \
           --namespace default
 
     # - name: Deployment validation

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/.github/workflows/smart-auto-release.yml

@@ -53,40 +53,44 @@ jobs:
       run: |
         echo "Getting current versions..."
         
-        # Get latest PyPI version using helper script
-        PYPI_VERSION=$(python scripts/get-pypi-version.py ${{ env.PACKAGE_NAME }})
-        echo "PYPI_VERSION=$PYPI_VERSION" >> $GITHUB_OUTPUT
-        
-        # Get remote-requirements.txt version
+        # Get merged branch (dv-stage) requirements version
         if [ -f "${{ env.REQUIREMENTS_FILE }}" ]; then
-          REQUIREMENTS_VERSION=$(grep "${{ env.PACKAGE_NAME }}" ${{ env.REQUIREMENTS_FILE }} | sed -n 's/.*==\([^]]*\).*/\1/p')
-          echo "REQUIREMENTS_VERSION=$REQUIREMENTS_VERSION" >> $GITHUB_OUTPUT
+          MERGED_REQUIREMENTS_VERSION=$(grep "${{ env.PACKAGE_NAME }}" ${{ env.REQUIREMENTS_FILE }} | sed -n 's/.*==\([^]]*\).*/\1/p')
+          echo "MERGED_REQUIREMENTS_VERSION=$MERGED_REQUIREMENTS_VERSION" >> $GITHUB_OUTPUT
         else
-          echo "REQUIREMENTS_VERSION=0.0.0.dev0" >> $GITHUB_OUTPUT
+          echo "MERGED_REQUIREMENTS_VERSION=0.0.0.dev0" >> $GITHUB_OUTPUT
+        fi
+        
+        # Get base branch requirements version
+        git show ${{ github.event.pull_request.base.sha }}:${{ env.REQUIREMENTS_FILE }} > base_requirements.txt 2>/dev/null || echo "dv-pipecat-ai==0.0.0.dev0" > base_requirements.txt
+        BASE_REQUIREMENTS_VERSION=$(grep "${{ env.PACKAGE_NAME }}" base_requirements.txt | sed -n 's/.*==\([^]]*\).*/\1/p')
+        if [ -z "$BASE_REQUIREMENTS_VERSION" ]; then
+          BASE_REQUIREMENTS_VERSION="0.0.0.dev0"
         fi
+        echo "BASE_REQUIREMENTS_VERSION=$BASE_REQUIREMENTS_VERSION" >> $GITHUB_OUTPUT
         
         echo "📊 Version Status:"
-        echo "   PyPI version: $PYPI_VERSION"
-        echo "   Requirements version: $REQUIREMENTS_VERSION"
+        echo "   Base branch requirements version: $BASE_REQUIREMENTS_VERSION"
+        echo "   Merged branch requirements version: $MERGED_REQUIREMENTS_VERSION"
 
     - name: Decide release action
       if: steps.check-changes.outputs.HAS_PIPECAT_CHANGES == 'true'
       id: decision
       run: |
-        PYPI_VERSION="${{ steps.versions.outputs.PYPI_VERSION }}"
-        REQUIREMENTS_VERSION="${{ steps.versions.outputs.REQUIREMENTS_VERSION }}"
+        BASE_VERSION="${{ steps.versions.outputs.BASE_REQUIREMENTS_VERSION }}"
+        MERGED_VERSION="${{ steps.versions.outputs.MERGED_REQUIREMENTS_VERSION }}"
         
         echo "🤔 Decision Logic:"
-        echo "   PyPI version: $PYPI_VERSION"
-        echo "   Requirements version: $REQUIREMENTS_VERSION"
+        echo "   Base branch version: $BASE_VERSION"
+        echo "   Merged branch version: $MERGED_VERSION"
         
-        if [ "$PYPI_VERSION" = "$REQUIREMENTS_VERSION" ]; then
+        if [ "$BASE_VERSION" = "$MERGED_VERSION" ]; then
           echo "SHOULD_RELEASE=true" >> $GITHUB_OUTPUT
-          echo "REASON=Versions match - auto-bumping needed" >> $GITHUB_OUTPUT
-          echo "✅ Decision: AUTO-RELEASE (versions match)"
+          echo "REASON=Versions match between branches - auto-bumping needed" >> $GITHUB_OUTPUT
+          echo "✅ Decision: AUTO-RELEASE (versions match between branches)"
         else
           echo "SHOULD_RELEASE=false" >> $GITHUB_OUTPUT
-          echo "REASON=Developer already updated version" >> $GITHUB_OUTPUT
+          echo "REASON=Developer already updated version in this PR" >> $GITHUB_OUTPUT
           echo "⏭️  Decision: SKIP (developer handled versioning)"
         fi
 
@@ -98,7 +102,7 @@ jobs:
           SKIP_REASON="No src/pipecat changes in this PR"
         else
           echo "⏭️  SKIPPING: ${{ steps.decision.outputs.REASON }}"
-          SKIP_REASON="Developer already updated version"
+          SKIP_REASON="Developer already updated version in this PR"
         fi
         echo "Skip reason: $SKIP_REASON"
 

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/.gitignore

@@ -6,7 +6,7 @@ venv
 .venv
 /.idea
 #*#
-data/
+# data/
 # Distribution / packaging
 .Python
 build/

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.82.dev776
+Version: 0.0.82.dev807
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/k8s/dv-pipecat/templates/keda-scaledobject.yaml

@@ -44,11 +44,12 @@ spec:
       name: {{ include "dv-pipecat.fullname" . }}-http-auth
     metadata:
       # The URL of your API
-      url: "https://67397cb486a3.ngrok-free.app/ca/api/v0/admin/global/predicted-concurrency"
+      # url: "https://67397cb486a3.ngrok-free.app/ca/api/v0/admin/global/predicted-pods"
+      url: {{ .Values.CALLING_BACKEND_URL }}/admin/global/predicted-pods
       # The JMESPath to find the number in the JSON response  
-      valueLocation: {{ .Values.keda.jsonPath | default "concurrency" | quote }}
+      valueLocation: {{ .Values.keda.jsonPath | default "predicted_pods" | quote }}
       # This is the divisor. KEDA calculates: desired_pods = (api_value / targetValue)
-      targetValue: {{ .Values.keda.targetValue | default "5" | quote }}
+      targetValue: {{ .Values.keda.targetValue | default "1" | quote }}
       # Authentication configuration
       authMode: "apiKey"
       method: "header"

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/k8s/dv-pipecat/values-prod.yaml

@@ -66,9 +66,9 @@ terminationGracePeriodSeconds: 270 # 4.5 minutes
 
 # KEDA Configuration for production
 keda:
-  enabled: false
-  jsonPath: "concurrency"
-  targetValue: "5"
+  enabled: true
+  jsonPath: "predicted_pods"
+  targetValue: "1"
   minReplicaCount: 4
   maxReplicaCount: 200
   pollingInterval: 60

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/k8s/dv-pipecat/values-stage.yaml

@@ -61,10 +61,10 @@ terminationGracePeriodSeconds: 270 # 4.5 minutes
 # KEDA Configuration for staging
 keda:
   enabled: true
-  jsonPath: "concurrency"
-  targetValue: "5"
+  jsonPath: "predicted_pods"
+  targetValue: "1"
   minReplicaCount: 1
-  maxReplicaCount: 30
+  maxReplicaCount: 2
   pollingInterval: 30
   cooldownPeriod: 30
   # Staging-optimized scaling behavior to prevent fluctuations

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/k8s/dv-pipecat/values.yaml

@@ -129,9 +129,9 @@ envFrom:
 keda:
   enabled: false
   # JSON path to extract the scheduled calls value
-  jsonPath: "concurrency"
+  jsonPath: "predicted_pods"
   # Target value for scaling (calls per pod)
-  targetValue: "5"
+  targetValue: "1"
   # HTTP method for API calls
   httpMethod: "GET"
   # Custom HTTP headers (optional)

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.82.dev776
+Version: 0.0.82.dev807
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev807}/src/dv_pipecat_ai.egg-info/SOURCES.txt

@@ -358,6 +358,8 @@ src/pipecat/services/together/__init__.py
 src/pipecat/services/together/llm.py
 src/pipecat/services/ultravox/__init__.py
 src/pipecat/services/ultravox/stt.py
+src/pipecat/services/vistaar/__init__.py
+src/pipecat/services/vistaar/llm.py
 src/pipecat/services/whisper/__init__.py
 src/pipecat/services/whisper/base_stt.py
 src/pipecat/services/whisper/stt.py

dv_pipecat_ai-0.0.82.dev807/src/pipecat/services/vistaar/__init__.py

@@ -0,0 +1,5 @@
+"""Vistaar AI service implementations."""
+
+from .llm import VistaarLLMService
+
+__all__ = ["VistaarLLMService"]

dv_pipecat_ai-0.0.82.dev807/src/pipecat/services/vistaar/llm.py

@@ -0,0 +1,377 @@
+"""Vistaar LLM Service implementation."""
+
+import asyncio
+import json
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Any, AsyncGenerator, Dict, Optional
+from urllib.parse import urlencode
+
+import httpx
+from loguru import logger
+from pydantic import BaseModel, Field
+
+from pipecat.frames.frames import (
+    Frame,
+    LLMFullResponseEndFrame,
+    LLMFullResponseStartFrame,
+    LLMMessagesFrame,
+    LLMTextFrame,
+    LLMUpdateSettingsFrame,
+    StartInterruptionFrame,
+    StopInterruptionFrame,
+)
+from pipecat.processors.aggregators.llm_response import (
+    LLMAssistantAggregatorParams,
+    LLMUserAggregatorParams,
+)
+from pipecat.processors.aggregators.openai_llm_context import (
+    OpenAILLMContext,
+    OpenAILLMContextFrame,
+)
+from pipecat.services.openai.llm import (
+    OpenAIAssistantContextAggregator,
+    OpenAIContextAggregatorPair,
+    OpenAIUserContextAggregator,
+)
+from pipecat.processors.frame_processor import FrameDirection
+from pipecat.services.llm_service import LLMService
+
+
+class VistaarLLMService(LLMService):
+    """A service for interacting with Vistaar's voice API using Server-Sent Events.
+
+    This service handles text generation through Vistaar's SSE endpoint which
+    streams responses in real-time. Vistaar maintains all conversation context
+    server-side via session_id, so we only send the latest user message.
+    """
+
+    class InputParams(BaseModel):
+        """Input parameters for Vistaar model configuration.
+
+        Parameters:
+            source_lang: Source language code (e.g., 'mr' for Marathi, 'hi' for Hindi).
+            target_lang: Target language code for responses.
+            session_id: Session ID for maintaining conversation context.
+            extra: Additional model-specific parameters.
+        """
+
+        source_lang: Optional[str] = Field(default="mr")
+        target_lang: Optional[str] = Field(default="mr")
+        session_id: Optional[str] = Field(default=None)
+        extra: Optional[Dict[str, Any]] = Field(default_factory=dict)
+
+    def __init__(
+        self,
+        *,
+        base_url: str = "https://vistaar.kenpath.ai/api",
+        params: Optional[InputParams] = None,
+        timeout: float = 30.0,
+        **kwargs,
+    ):
+        """Initialize Vistaar LLM service.
+
+        Args:
+            base_url: The base URL for Vistaar API. Defaults to "https://vistaar.kenpath.ai/api".
+            params: Input parameters for model configuration and behavior.
+            timeout: Request timeout in seconds. Defaults to 30.0 seconds.
+            **kwargs: Additional arguments passed to the parent LLMService.
+        """
+        super().__init__(**kwargs)
+
+        params = params or VistaarLLMService.InputParams()
+
+        self._base_url = base_url.rstrip("/")
+        self._source_lang = params.source_lang
+        self._target_lang = params.target_lang
+        self._session_id = params.session_id or str(uuid.uuid4())
+        self._extra = params.extra if isinstance(params.extra, dict) else {}
+        self._timeout = timeout
+
+        # Create an async HTTP client
+        self._client = httpx.AsyncClient(timeout=httpx.Timeout(self._timeout))
+
+        # Interruption handling state
+        self._current_response = None  # Track current HTTP response stream
+        self._is_interrupted = False  # Track if current generation was interrupted
+        self._partial_response = []  # Track what was actually sent before interruption
+
+        logger.info(
+            f"Vistaar LLM initialized - Base URL: {self._base_url}, Session ID: {self._session_id}, Source Lang: {self._source_lang}, Target Lang: {self._target_lang}, Timeout: {self._timeout}s"
+        )
+
+    async def _extract_messages_to_query(self, context: OpenAILLMContext) -> str:
+        """Extract only the last user message from context.
+
+        Since Vistaar maintains context server-side via session_id,
+        we only need to send the most recent user message.
+
+        As a fallback for context synchronization, we can optionally include
+        information about interrupted responses.
+
+        Args:
+            context: The OpenAI LLM context containing messages.
+
+        Returns:
+            The last user message as a query string, optionally with context hints.
+        """
+        messages = context.get_messages()
+        query_parts = []
+
+        # Include interrupted response context as a hint (optional fallback strategy)
+        if hasattr(self, "_last_interrupted_response"):
+            interrupted_text = self._last_interrupted_response[:100]  # Limit length
+            query_parts.append(
+                f"[Context: I was previously saying '{interrupted_text}...' when interrupted]"
+            )
+            # Clear the interrupted response after using it
+            delattr(self, "_last_interrupted_response")
+
+        # Find the last user message (iterate in reverse for efficiency)
+        for message in reversed(messages):
+            if message.get("role") == "user":
+                content = message.get("content", "")
+
+                # Handle content that might be a list (for multimodal messages)
+                if isinstance(content, list):
+                    text_parts = [
+                        item.get("text", "") for item in content if item.get("type") == "text"
+                    ]
+                    content = " ".join(text_parts)
+
+                if isinstance(content, str):
+                    query_parts.append(content.strip())
+                    break
+
+        # If no user message found, return empty string or just context
+        return " ".join(query_parts) if query_parts else ""
+
+    async def _handle_interruption(self):
+        """Handle interruption by cancelling ongoing stream."""
+        logger.debug("Handling interruption for Vistaar LLM")
+
+        # Set interruption flag
+        self._is_interrupted = True
+
+        # Cancel ongoing HTTP response stream if active
+        if self._current_response:
+            try:
+                await self._current_response.aclose()
+                logger.debug("Closed active Vistaar response stream")
+            except Exception as e:
+                logger.warning(f"Error closing Vistaar response stream: {e}")
+            finally:
+                self._current_response = None
+
+        # Store partial response for potential inclusion in next query
+        if self._partial_response:
+            partial_text = "".join(self._partial_response)
+            logger.debug(f"Storing interrupted response: {partial_text[:100]}...")
+            # Store the interrupted response for next query context
+            self._last_interrupted_response = partial_text
+
+        # Clear current partial response
+        self._partial_response = []
+
+    async def _stream_response(self, query: str) -> AsyncGenerator[str, None]:
+        """Stream response from Vistaar API using Server-Sent Events.
+
+        Args:
+            query: The user's query to send to the API.
+
+        Yields:
+            Text chunks from the streaming response.
+        """
+        # Prepare query parameters
+        params = {
+            "query": query,
+            "session_id": self._session_id,
+            "source_lang": self._source_lang,
+            "target_lang": self._target_lang,
+        }
+
+        # Add any extra parameters
+        params.update(self._extra)
+
+        # Construct the full URL with query parameters
+        url = f"{self._base_url}/voice/?{urlencode(params)}"
+
+        logger.info(
+            f"Vistaar API request - URL: {self._base_url}/voice/, Session: {self._session_id}, Query: {query[:100]}..."
+        )
+        logger.debug(f"Full URL with params: {url}")
+
+        # Reset interruption state and partial response for new request
+        self._is_interrupted = False
+        self._partial_response = []
+
+        try:
+            # Use httpx to handle SSE streaming
+            async with self._client.stream("GET", url) as response:
+                self._current_response = response  # Store for potential cancellation
+                response.raise_for_status()
+
+                # Process the SSE stream
+                async for line in response.aiter_lines():
+                    # Check for interruption before processing each line
+                    if self._is_interrupted:
+                        logger.debug("Stream interrupted, stopping processing")
+                        break
+
+                    if not line:
+                        continue
+
+                    self._partial_response.append(line)  # Track what we're sending
+                    yield line
+
+        except httpx.HTTPStatusError as e:
+            logger.error(
+                f"Vistaar HTTP error - Status: {e.response.status_code}, URL: {url}, Response: {e.response.text if hasattr(e.response, 'text') else 'N/A'}"
+            )
+            raise
+        except httpx.TimeoutException as e:
+            logger.error(f"Vistaar timeout error - URL: {url}, Timeout: {self._timeout}s")
+            raise
+        except Exception as e:
+            logger.error(
+                f"Vistaar unexpected error - Type: {type(e).__name__}, Message: {str(e)}, URL: {url}"
+            )
+            raise
+        finally:
+            # Clean up response reference
+            self._current_response = None
+
+    async def _process_context(self, context: OpenAILLMContext):
+        """Process the LLM context and generate streaming response.
+
+        Args:
+            context: The OpenAI LLM context containing messages to process.
+        """
+        logger.info(f"Vistaar processing context - Session: {self._session_id}")
+        try:
+            # Extract query from context
+            query = await self._extract_messages_to_query(context)
+
+            if not query:
+                logger.warning(
+                    f"Vistaar: No query extracted from context - Session: {self._session_id}"
+                )
+                return
+
+            logger.info(f"Vistaar extracted query: {query}")
+
+            logger.debug(f"Processing query: {query[:100]}...")
+
+            # Start response
+            await self.push_frame(LLMFullResponseStartFrame())
+            await self.start_processing_metrics()
+            await self.start_ttfb_metrics()
+
+            first_chunk = True
+            full_response = []
+
+            # Stream the response
+            async for text_chunk in self._stream_response(query):
+                if first_chunk:
+                    await self.stop_ttfb_metrics()
+                    first_chunk = False
+
+                # Push each text chunk as it arrives
+                await self.push_frame(LLMTextFrame(text=text_chunk))
+                full_response.append(text_chunk)
+
+            # No need to update context - Vistaar maintains all context server-side
+            # The response has already been sent via LLMTextFrame chunks
+
+        except Exception as e:
+            logger.error(
+                f"Vistaar context processing error - Session: {self._session_id}, Error: {type(e).__name__}: {str(e)}"
+            )
+            import traceback
+
+            logger.error(f"Vistaar traceback: {traceback.format_exc()}")
+            raise
+        finally:
+            await self.stop_processing_metrics()
+            await self.push_frame(LLMFullResponseEndFrame())
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process frames for LLM completion requests.
+
+        Handles OpenAILLMContextFrame, LLMMessagesFrame, and LLMUpdateSettingsFrame
+        to trigger LLM completions and manage settings.
+
+        Args:
+            frame: The frame to process.
+            direction: The direction of frame processing.
+        """
+        await super().process_frame(frame, direction)
+        context = None
+        if isinstance(frame, StartInterruptionFrame):
+            await self._handle_interruption()
+            await self.push_frame(frame, direction)
+            return
+        elif isinstance(frame, OpenAILLMContextFrame):
+            context = frame.context
+        elif isinstance(frame, LLMMessagesFrame):
+            context = OpenAILLMContext.from_messages(frame.messages)
+        elif isinstance(frame, LLMUpdateSettingsFrame):
+            # Update settings if needed
+            settings = frame.settings
+            if "source_lang" in settings:
+                self._source_lang = settings["source_lang"]
+            if "target_lang" in settings:
+                self._target_lang = settings["target_lang"]
+            if "session_id" in settings:
+                self._session_id = settings["session_id"]
+            logger.debug(f"Updated Vistaar settings: {settings}")
+        else:
+            await self.push_frame(frame, direction)
+
+        if context:
+            try:
+                await self._process_context(context)
+            except httpx.TimeoutException:
+                logger.error("Timeout while processing Vistaar request")
+                await self._call_event_handler("on_completion_timeout")
+            except Exception as e:
+                logger.error(f"Error processing Vistaar request: {e}")
+                raise
+
+    def create_context_aggregator(
+        self,
+        context: OpenAILLMContext,
+        *,
+        user_params: LLMUserAggregatorParams = LLMUserAggregatorParams(),
+        assistant_params: LLMAssistantAggregatorParams = LLMAssistantAggregatorParams(),
+    ) -> OpenAIContextAggregatorPair:
+        """Create context aggregators for Vistaar LLM.
+
+        Since Vistaar uses OpenAI-compatible message format, we reuse OpenAI's
+        context aggregators directly, similar to how Groq and Azure services work.
+
+        Args:
+            context: The LLM context to create aggregators for.
+            user_params: Parameters for user message aggregation.
+            assistant_params: Parameters for assistant message aggregation.
+
+        Returns:
+            OpenAIContextAggregatorPair: A pair of OpenAI context aggregators,
+            compatible with Vistaar's OpenAI-like message format.
+        """
+        context.set_llm_adapter(self.get_llm_adapter())
+        user = OpenAIUserContextAggregator(context, params=user_params)
+        assistant = OpenAIAssistantContextAggregator(context, params=assistant_params)
+        return OpenAIContextAggregatorPair(_user=user, _assistant=assistant)
+
+    async def close(self):
+        """Close the HTTP client when the service is destroyed."""
+        await self._client.aclose()
+
+    def __del__(self):
+        """Ensure the client is closed on deletion."""
+        try:
+            asyncio.create_task(self._client.aclose())
+        except:
+            pass