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

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

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

@@ -1,7 +1,7 @@
 {
   "tag": "0.0.92",
-  "distance": 96,
-  "node": "gb8e2f839eec7d648f881f3cb917930f1e0b87afe",
+  "distance": 97,
+  "node": "g50ae663b4aeeb7ceb9c3ea3ad76124939b8bbfa5",
   "dirty": false,
   "branch": "dv-stage",
   "node_date": "2026-06-25"

{dv_pipecat_ai-0.0.93.dev96 → dv_pipecat_ai-0.0.93.dev97}/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.dev97}/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.