dv-pipecat-ai 0.0.93.dev59__tar.gz → 0.0.93.dev61__tar.gz

{dv_pipecat_ai-0.0.93.dev59/src/dv_pipecat_ai.egg-info → dv_pipecat_ai-0.0.93.dev61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev59
+Version: 0.0.93.dev61
 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.93.dev59 → dv_pipecat_ai-0.0.93.dev61/src/dv_pipecat_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev59
+Version: 0.0.93.dev61
 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.93.dev59 → dv_pipecat_ai-0.0.93.dev61}/src/dv_pipecat_ai.egg-info/SOURCES.txt

@@ -411,6 +411,8 @@ src/pipecat/services/rime/__init__.py
 src/pipecat/services/rime/tts.py
 src/pipecat/services/ringg/__init__.py
 src/pipecat/services/ringg/stt.py
+src/pipecat/services/ringg_qwen/__init__.py
+src/pipecat/services/ringg_qwen/llm.py
 src/pipecat/services/riva/__init__.py
 src/pipecat/services/riva/stt.py
 src/pipecat/services/riva/tts.py

dv_pipecat_ai-0.0.93.dev61/src/pipecat/services/ringg_qwen/__init__.py

@@ -0,0 +1,13 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import sys
+
+from pipecat.services import DeprecatedModuleProxy
+
+from .llm import *
+
+sys.modules[__name__] = DeprecatedModuleProxy(globals(), "ringg_qwen", "ringg_qwen.llm")

dv_pipecat_ai-0.0.93.dev61/src/pipecat/services/ringg_qwen/llm.py

@@ -0,0 +1,162 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Self-hosted Qwen3 LLM service (Ringg) — vLLM on a Google Vertex AI endpoint.
+
+The deployed endpoint is reachable only through Vertex's ``:rawPredict`` custom
+method (``:streamRawPredict`` is rejected by this deployment), but it replies
+with standard OpenAI-shaped SSE when the request body sets ``stream: true``. We
+therefore reuse the OpenAI client and rewrite the request path from
+``/chat/completions`` to ``:rawPredict`` with a small httpx transport.
+Authentication reuses the GCP service-account token logic from
+``GoogleVertexLLMService`` (a ~1h OAuth token passed as the bearer ``api_key``).
+
+Note:
+    pipecat-flows drives node transitions via function calls. The vLLM
+    deployment must be started with ``--enable-auto-tool-choice`` and a
+    ``--tool-call-parser`` for tool calling (and therefore flows) to work.
+"""
+
+from typing import Optional
+
+import httpx
+from loguru import logger
+from openai import AsyncOpenAI, DefaultAsyncHttpxClient
+
+from pipecat.services.google.llm_vertex import GoogleVertexLLMService
+from pipecat.services.openai.llm import OpenAILLMService
+
+_CHAT_COMPLETIONS_SUFFIX = "/chat/completions"
+_RAW_PREDICT_SUFFIX = ":rawPredict"
+
+
+class _VertexRawPredictTransport(httpx.AsyncBaseTransport):
+    """Rewrites the OpenAI SDK's ``/chat/completions`` path to Vertex ``:rawPredict``.
+
+    The vLLM model deployed on this Vertex endpoint only accepts the
+    ``:rawPredict`` custom method; streaming still works because the request body
+    carries ``stream: true`` and the endpoint replies with OpenAI-style SSE.
+    """
+
+    def __init__(self, inner: httpx.AsyncBaseTransport):
+        self._inner = inner
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        path = request.url.path
+        if path.endswith(_CHAT_COMPLETIONS_SUFFIX):
+            new_path = path[: -len(_CHAT_COMPLETIONS_SUFFIX)] + _RAW_PREDICT_SUFFIX
+            request.url = request.url.copy_with(path=new_path)
+        return await self._inner.handle_async_request(request)
+
+    async def aclose(self) -> None:
+        await self._inner.aclose()
+
+
+class RinggQwenLLMService(OpenAILLMService):
+    """Self-hosted Qwen3 (vLLM on Vertex AI) via the OpenAI-compatible interface.
+
+    Reuses ``GoogleVertexLLMService``'s GCP service-account auth and points the
+    OpenAI client at the deployed Vertex endpoint's ``:rawPredict`` route.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: str,
+        endpoint_id: str,
+        project_id: str,
+        location: str,
+        credentials: Optional[str] = None,
+        credentials_path: Optional[str] = None,
+        project_number: str = "",
+        dedicated: bool = False,
+        enable_tool_calling: bool = True,
+        **kwargs,
+    ):
+        """Initialize the Ringg Qwen LLM service.
+
+        Endpoint identity (``model``, ``endpoint_id``, ``project_id``,
+        ``location``) is required and supplied by the caller — no deployment
+        values are baked into this service.
+
+        Args:
+            model: vLLM model identifier served by the endpoint
+                (e.g. "Qwen/Qwen3-4B-Instruct-2507").
+            endpoint_id: Vertex AI endpoint id hosting the model.
+            project_id: Google Cloud project id.
+            location: GCP region of the endpoint (e.g. "asia-south1").
+            credentials: JSON string of GCP service-account credentials.
+            credentials_path: Path to the GCP service-account JSON file.
+            project_number: Google Cloud project number; required only when
+                ``dedicated`` is True (used to build the dedicated endpoint DNS).
+            dedicated: Whether the endpoint uses a dedicated DNS host.
+            enable_tool_calling: Whether the vLLM deployment was started with
+                ``--enable-auto-tool-choice`` + ``--tool-call-parser`` (required
+                for flow node transitions and function calls). Defaults to True.
+                Set False if the deployment doesn't support tools yet: ``tools``
+                and ``tool_choice`` are then stripped from every request so the
+                endpoint doesn't reject them with a 400 (plain chat only).
+            **kwargs: Additional arguments passed to OpenAILLMService.
+        """
+        if dedicated and not project_number:
+            raise ValueError("project_number is required when dedicated=True")
+        self._enable_tool_calling = enable_tool_calling
+        host = (
+            f"{endpoint_id}.{location}-{project_number}.prediction.vertexai.goog"
+            if dedicated
+            else f"{location}-aiplatform.googleapis.com"
+        )
+        base_url = (
+            f"https://{host}/v1/projects/{project_id}/locations/{location}/endpoints/{endpoint_id}"
+        )
+        # Reuse GoogleVertexLLMService's GCP token minting (creds.json -> bearer token).
+        api_key = GoogleVertexLLMService._get_api_token(credentials, credentials_path)
+
+        super().__init__(api_key=api_key, base_url=base_url, model=model, **kwargs)
+        logger.info(
+            f"Initialized Ringg Qwen LLM service "
+            f"(model={model}, endpoint={endpoint_id}, location={location}, dedicated={dedicated}, "
+            f"enable_tool_calling={enable_tool_calling})"
+        )
+        if not enable_tool_calling:
+            logger.warning(
+                "RinggQwenLLMService: tool calling disabled — tools/tool_choice will be "
+                "stripped from requests. Flow node transitions and function calls will NOT "
+                "work until the vLLM deployment enables tool calling and this is set True."
+            )
+
+    def build_chat_completion_params(self, params_from_context) -> dict:
+        """Build request params, dropping tools when the deployment can't handle them."""
+        params = super().build_chat_completion_params(params_from_context)
+        if not self._enable_tool_calling:
+            params.pop("tools", None)
+            params.pop("tool_choice", None)
+        return params
+
+    def create_client(
+        self,
+        api_key=None,
+        base_url=None,
+        organization=None,
+        project=None,
+        default_headers=None,
+        **kwargs,
+    ):
+        """Create an OpenAI client whose requests are rewritten to Vertex ``:rawPredict``."""
+        inner = httpx.AsyncHTTPTransport(
+            limits=httpx.Limits(
+                max_keepalive_connections=100, max_connections=1000, keepalive_expiry=None
+            )
+        )
+        http_client = DefaultAsyncHttpxClient(transport=_VertexRawPredictTransport(inner))
+        return AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            organization=organization,
+            project=project,
+            http_client=http_client,
+            default_headers=default_headers,
+        )