dv-pipecat-ai 0.0.93.dev96__tar.gz → 0.0.93.dev98__tar.gz

{dv_pipecat_ai-0.0.93.dev96/src/dv_pipecat_ai.egg-info → dv_pipecat_ai-0.0.93.dev98}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev96
+Version: 0.0.93.dev98
 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.dev98/src/dv_pipecat_ai.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.92",
+  "distance": 98,
+  "node": "g792fd951f4d45dec678ae4393d1fd45fd731ceeb",
+  "dirty": false,
+  "branch": "dv-stage",
+  "node_date": "2026-07-03"
+}

{dv_pipecat_ai-0.0.93.dev96 → dv_pipecat_ai-0.0.93.dev98}/src/pipecat/processors/aggregators/llm_response.py

@@ -872,20 +872,6 @@ class LLMAssistantContextAggregator(LLMContextResponseAggregator):
         self._function_calls_in_progress: Dict[str, Optional[FunctionCallInProgressFrame]] = {}
         self._context_updated_tasks: Set[asyncio.Task] = set()
 
-        # Monotonic id of the current LLM response cycle, bumped on every
-        # LLMFullResponseStartFrame. Used to tell whether spoken text was
-        # produced in the SAME completion that issued a tool call (so it should
-        # be folded into that tool-call message) versus a later continuation
-        # response (which must remain a separate message). See
-        # `handle_function_call_in_progress` / `handle_aggregation` in the
-        # OpenAI subclass.
-        self._response_seq = 0
-        # Response-seq stamped onto the current text aggregation when it starts.
-        self._aggregation_seq: Optional[int] = None
-        # (message, response_seq) of a content-less tool-call message that may
-        # still absorb same-turn spoken text; consumed by `handle_aggregation`.
-        self._pending_tool_call_merge: Optional[tuple] = None
-
     @property
     def has_function_calls_in_progress(self) -> bool:
         """Check if there are any function calls currently in progress.
@@ -1100,7 +1086,6 @@ class LLMAssistantContextAggregator(LLMContextResponseAggregator):
 
     async def _handle_llm_start(self, _: LLMFullResponseStartFrame):
         self._started += 1
-        self._response_seq += 1
 
     async def _handle_llm_end(self, _: LLMFullResponseEndFrame):
         self._started -= 1
@@ -1112,21 +1097,6 @@ class LLMAssistantContextAggregator(LLMContextResponseAggregator):
         if isinstance(frame, TTSTextFrame) and not frame.add_to_llm_context:
             return
 
-        if not self._aggregation:
-            # First text frame of a new aggregation: remember which response
-            # cycle it belongs to, so we can later decide whether it should be
-            # folded into a same-turn tool-call message.
-            self._aggregation_seq = self._response_seq
-        elif self._aggregation_seq != self._response_seq:
-            # A newer response cycle produced text before the previous
-            # aggregation was flushed — e.g. a tool-result continuation (the
-            # FunctionCallResultFrame is a SystemFrame) racing a long TTS
-            # playback that is still holding the response-end / bot-stopped
-            # frames. The buffer now mixes two response cycles, so it must NOT
-            # be folded into the earlier turn's tool-call message; mark it
-            # un-mergeable.
-            self._aggregation_seq = None
-
         if self._params.expect_stripped_words:
             self._aggregation += f" {frame.text}" if self._aggregation else frame.text
         else:

{dv_pipecat_ai-0.0.93.dev96 → dv_pipecat_ai-0.0.93.dev98}/src/pipecat/services/elevenlabs/tts.py

@@ -571,7 +571,19 @@ class ElevenLabsTTSService(AudioContextWordTTSService):
                 self.logger.debug("Disconnecting from ElevenLabs")
                 # Close all contexts and the socket
                 if self._context_id:
+                    # The multi-stream protocol tears down in two steps: we ask
+                    # ElevenLabs to close, then it closes. Wait for its close
+                    # before forcing ours, so we don't race the closing handshake
+                    # (which otherwise ends a notable fraction of sessions in a
+                    # 1006 close). The timeout is only a fallback ceiling; the
+                    # clean close normally arrives well within it.
                     await self._websocket.send(json.dumps({"close_socket": True}))
+                    try:
+                        await asyncio.wait_for(self._websocket.wait_closed(), timeout=2.0)
+                    except TimeoutError:
+                        self.logger.debug(
+                            "ElevenLabs did not close the WebSocket within 2.0s; closing from our side"
+                        )
                 await self._websocket.close()
                 self.logger.debug("Disconnected from ElevenLabs")
         except Exception as e:

{dv_pipecat_ai-0.0.93.dev96 → dv_pipecat_ai-0.0.93.dev98}/src/pipecat/services/openai/llm.py

@@ -126,38 +126,6 @@ class OpenAIAssistantContextAggregator(LLMAssistantContextAggregator):
     tool usage tracking, and image message handling.
     """
 
-    async def handle_aggregation(self, aggregation: str):
-        """Add the aggregated assistant text to the context.
-
-        When the assistant speaks text AND issues a tool call in the same LLM
-        completion, the tool-call message (and its result) are written to the
-        context immediately, while this spoken-text aggregation is only flushed
-        when the bot stops speaking — i.e. after the tool result is already in
-        the context. Appending the text as a trailing message then produces a
-        scrambled order (assistant{tool_calls} -> tool{result} ->
-        assistant{text}) that makes the post-function continuation re-speak the
-        same line.
-
-        To keep OpenAI's canonical ordering (assistant{content, tool_calls} ->
-        tool{result}), fold the text into that content-less tool-call message
-        instead. Only do so when the text was produced in the SAME response
-        cycle that issued the call (``_aggregation_seq`` matches the seq stamped
-        on the pending tool call); text from a later continuation response is a
-        genuine reply to the result and is appended normally.
-        """
-        pending = self._pending_tool_call_merge
-        self._pending_tool_call_merge = None
-        if (
-            pending is not None
-            and pending[1] == self._aggregation_seq
-            and not pending[0].get("content")
-            and pending[0] in self._context.messages
-        ):
-            pending[0]["content"] = aggregation
-            return
-
-        self._context.add_message({"role": "assistant", "content": aggregation})
-
     async def handle_function_call_in_progress(self, frame: FunctionCallInProgressFrame):
         """Handle a function call in progress.
 
@@ -167,20 +135,21 @@ class OpenAIAssistantContextAggregator(LLMAssistantContextAggregator):
         Args:
             frame: Frame containing function call progress information.
         """
-        tool_call_message = {
-            "role": "assistant",
-            "tool_calls": [
-                {
-                    "id": frame.tool_call_id,
-                    "function": {
-                        "name": frame.function_name,
-                        "arguments": json.dumps(frame.arguments),
-                    },
-                    "type": "function",
-                }
-            ],
-        }
-        self._context.add_message(tool_call_message)
+        self._context.add_message(
+            {
+                "role": "assistant",
+                "tool_calls": [
+                    {
+                        "id": frame.tool_call_id,
+                        "function": {
+                            "name": frame.function_name,
+                            "arguments": json.dumps(frame.arguments),
+                        },
+                        "type": "function",
+                    }
+                ],
+            }
+        )
         self._context.add_message(
             {
                 "role": "tool",
@@ -189,17 +158,6 @@ class OpenAIAssistantContextAggregator(LLMAssistantContextAggregator):
             }
         )
 
-        # If the assistant also speaks text in this same response cycle, that
-        # text is committed only once the bot stops speaking — after this
-        # content-less tool-call message. Remember the first such call of the
-        # cycle so `handle_aggregation` can fold the spoken text into it instead
-        # of letting it land after the tool result. (See `handle_aggregation`.)
-        if (
-            self._pending_tool_call_merge is None
-            or self._pending_tool_call_merge[1] != self._response_seq
-        ):
-            self._pending_tool_call_merge = (tool_call_message, self._response_seq)
-
     async def handle_function_call_result(self, frame: FunctionCallResultFrame):
         """Handle the result of a function call.
 

dv_pipecat_ai-0.0.93.dev96/src/dv_pipecat_ai.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.0.92",
-  "distance": 96,
-  "node": "gb8e2f839eec7d648f881f3cb917930f1e0b87afe",
-  "dirty": false,
-  "branch": "dv-stage",
-  "node_date": "2026-06-25"
-}