dv-pipecat-flows 0.0.22.dev1516__tar.gz → 0.0.22.dev1700__tar.gz

dv_pipecat_flows-0.0.22.dev1700/.python-version

@@ -0,0 +1 @@
+3.12.0

{dv_pipecat_flows-0.0.22.dev1516/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.22.dev1700}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.22.dev1516
+Version: 0.0.22.dev1700
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows
@@ -309,4 +309,3 @@ We aim to review all contributions promptly and provide constructive feedback to
 ➡️ [Reach us on X](https://x.com/pipecat_ai)
 
 
-

{dv_pipecat_flows-0.0.22.dev1516 → dv_pipecat_flows-0.0.22.dev1700}/README.md

@@ -284,4 +284,3 @@ We aim to review all contributions promptly and provide constructive feedback to
 ➡️ [Reach us on X](https://x.com/pipecat_ai)
 
 
-

{dv_pipecat_flows-0.0.22.dev1516 → dv_pipecat_flows-0.0.22.dev1700/src/dv_pipecat_flows.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.22.dev1516
+Version: 0.0.22.dev1700
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows
@@ -309,4 +309,3 @@ We aim to review all contributions promptly and provide constructive feedback to
 ➡️ [Reach us on X](https://x.com/pipecat_ai)
 
 
-

{dv_pipecat_flows-0.0.22.dev1516 → dv_pipecat_flows-0.0.22.dev1700}/src/dv_pipecat_flows.egg-info/SOURCES.txt

@@ -60,31 +60,6 @@ editor/js/utils/import.js
 editor/js/utils/validation.js
 editor/public/favicon.png
 editor/public/favicon.svg
-evals/kb/.gitignore
-evals/kb/README.md
-evals/kb/RESULTS.md
-evals/kb/UNIFIED_KB_BENCHMARKS.md
-evals/kb/chunkers.py
-evals/kb/contracts.py
-evals/kb/datagen/generate_corpus.py
-evals/kb/datagen/generate_dataset.py
-evals/kb/datagen/generate_hybrid.py
-evals/kb/datagen/templates/insurance.yaml
-evals/kb/datasets/.gitignore
-evals/kb/datasets/v1_hybrid/manifest.json
-evals/kb/datasets/v1_retrieval/manifest.json
-evals/kb/datasets/v1_retrieval_long/manifest.json
-evals/kb/datasets/v1_synthetic/manifest.json
-evals/kb/runners/run_filter_pick.py
-evals/kb/runners/run_filter_scaling.py
-evals/kb/runners/run_hybrid.py
-evals/kb/runners/run_latency.py
-evals/kb/runners/run_rerank.py
-evals/kb/runners/run_retrieval.py
-evals/kb/service/API.md
-evals/kb/service/__init__.py
-evals/kb/service/app.py
-evals/kb/service/jobs.py
 images/food-ordering-flow.png
 remote-asterisk-code/README.md
 remote-asterisk-code/extensions.conf

{dv_pipecat_flows-0.0.22.dev1516 → dv_pipecat_flows-0.0.22.dev1700}/src/pipecat_flows/actions.py

@@ -26,13 +26,14 @@ Actions are used to perform side effects during conversations, such as:
 import asyncio
 import inspect
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Dict, List, Optional
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Tuple
 
 from loguru import logger
 from pipecat.frames.frames import (
     BotStoppedSpeakingFrame,
     ControlFrame,
     EndFrame,
+    InterruptionFrame,
     ManuallySwitchServiceFrame,
     TTSSpeakFrame,
 )
@@ -97,6 +98,14 @@ class ActionManager:
         self._ongoing_actions_count = 0
         self._ongoing_actions_finished_event = asyncio.Event()
         self._deferred_post_actions: List[ActionConfig] = []
+        # Tracks whether an InterruptionFrame has been observed since the
+        # last action increment. The BotStoppedSpeakingFrame "interruption
+        # recovery" branch must only fire when a real interruption actually
+        # happened — otherwise a stale BotStoppedSpeakingFrame from a prior
+        # speech (e.g. cached intro completing while the first Speak node
+        # is already starting) would zero a legitimate in-flight count and
+        # release _ongoing_actions_finished_event prematurely.
+        self._seen_interruption_since_increment = False
 
         # Register built-in actions
         self._register_action("tts_say", self._handle_tts_action)
@@ -105,7 +114,12 @@ class ActionManager:
 
         # Add pipeline observation
         task.set_reached_downstream_filter(
-            (ActionFinishedFrame, FunctionActionFrame, BotStoppedSpeakingFrame)
+            (
+                ActionFinishedFrame,
+                FunctionActionFrame,
+                BotStoppedSpeakingFrame,
+                InterruptionFrame,
+            )
         )
 
         @task.event_handler("on_frame_reached_downstream")
@@ -147,16 +161,39 @@ class ActionManager:
                 #    Defensively reset on this frame so the engine doesn't
                 #    deadlock; skip the deferred post-actions since the action
                 #    didn't complete naturally.
-                if self._ongoing_actions_count > 0:
+                #
+                # Recovery is gated on `_seen_interruption_since_increment`:
+                # count>0 alone is ambiguous — a stale BotStoppedSpeakingFrame
+                # from a prior speech (e.g. cached intro completing after a
+                # new Speak's increment) would otherwise zero a legitimate
+                # in-flight count and unblock the next _set_node early.
+                if (
+                    self._ongoing_actions_count > 0
+                    and self._seen_interruption_since_increment
+                ):
                     logger.debug(
                         f"BotStoppedSpeaking with in-flight count="
-                        f"{self._ongoing_actions_count} — interrupted action; "
+                        f"{self._ongoing_actions_count} after InterruptionFrame; "
                         f"resetting to release _ongoing_actions_finished_event"
                     )
                     self._ongoing_actions_count = 0
                     self._ongoing_actions_finished_event.set()
+                    self._seen_interruption_since_increment = False
+                elif self._ongoing_actions_count > 0:
+                    # Stale frame from prior speech. Ignore — the real
+                    # in-flight action's ActionFinishedFrame is still coming.
+                    logger.debug(
+                        f"BotStoppedSpeaking with in-flight count="
+                        f"{self._ongoing_actions_count} but no InterruptionFrame "
+                        f"observed since last increment; treating as stale, "
+                        f"keeping counter intact"
+                    )
                 else:
                     await self._execute_deferred_post_actions()
+            elif isinstance(frame, InterruptionFrame):
+                # Mark — the very next BotStoppedSpeakingFrame is the truncated
+                # speech's stop and should trigger the recovery branch above.
+                self._seen_interruption_since_increment = True
             elif isinstance(frame, ActionFinishedFrame):
                 # Handle action finished
                 self._decrement_ongoing_actions_count()
@@ -368,7 +405,7 @@ class ActionManager:
         To prevent the LLM from immediately responding after TTS in pre-actions,
         set ``respond_immediately=false`` in the node configuration.
         """
-        text = self._pick_tts_variant(action)
+        text, text_raw, chosen_lang = self._pick_tts_variant(action)
         if not text:
             logger.error("TTS action missing 'text' / 'text_variants' field")
             return
@@ -387,8 +424,17 @@ class ActionManager:
             served_from_cache = False
             if cache_handler is not None:
                 try:
-                    text_raw = action.get("text_raw") or text
-                    served_from_cache = bool(await cache_handler(text=text, text_raw=text_raw))
+                    # Fall back to text when no raw template was emitted —
+                    # cache key derivation will treat the rendered text as
+                    # its own template (lower hit rate but always correct).
+                    effective_raw = text_raw or text
+                    served_from_cache = bool(
+                        await cache_handler(
+                            text=text,
+                            text_raw=effective_raw,
+                            language=chosen_lang,
+                        )
+                    )
                 except Exception as e:
                     logger.error(f"tts_say cache handler raised, falling back to live TTS: {e}")
                     served_from_cache = False
@@ -408,24 +454,35 @@ class ActionManager:
             self._decrement_ongoing_actions_count()
             logger.error(f"TTS error: {e}")
 
-    def _pick_tts_variant(self, action: dict) -> Optional[str]:
-        """Pick a variation string from ``text_variants`` (or return ``text``).
+    def _pick_tts_variant(
+        self, action: dict
+    ) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """Pick a variation string from ``text_variants``.
+
+        Returns ``(text, text_raw, chosen_lang)``:
+          * ``text`` — the picked variant (rendered string), or ``action["text"]``
+            when no variants are usable.
+          * ``text_raw`` — the matching unrendered template (with ``{{var}}``
+            markers intact) from ``action["text_raw_variants"][chosen_lang][idx]``
+            when present, else ``action["text_raw"]``, else mirrors ``text``.
+            Used by the split-cache to derive the stable prefix cache key.
+          * ``chosen_lang`` — the ISO key that won, or None when the legacy
+            ``text`` fallback was taken. Threaded down to the cache_handler
+            so the cache key can be language-scoped (different scripts must
+            not share a cache slot).
 
         Resolution order for the language key:
-            1. ``state["language"]`` (ISO 639-1, set by any Router-LLM's
-               auto-injected language extract).
+            1. ``state["language"]`` (set by Router-LLM auto-injected extract).
             2. ``action["fallback_language"]`` (the Speak's primary ISO).
             3. First key in ``text_variants``.
 
-        If a language is chosen but its variant list is empty / missing, falls
-        back through (2) and (3) in order. Cycling state lives on
-        :attr:`FlowManager._variant_usage` keyed by ``(speak_node_id, lang)`` —
-        every variant index is picked at most once until the set has been
-        exhausted, at which point it resets and the cycle restarts.
+        Cycling state lives on :attr:`FlowManager._variant_usage` keyed by
+        ``(speak_node_id, lang)`` — every variant index is picked at most
+        once until the set has been exhausted, at which point it resets.
         """
         variants = action.get("text_variants")
         if not isinstance(variants, dict) or not variants:
-            return action.get("text")
+            return action.get("text"), action.get("text_raw"), None
 
         active = (self._flow_manager.state or {}).get("language") if isinstance(
             self._flow_manager.state, dict
@@ -454,7 +511,19 @@ class ActionManager:
         if not chosen_list:
             # Variants dict is malformed (all keys empty); fall back to the
             # forward-compat `text` field if the lowerer emitted one.
-            return action.get("text")
+            return action.get("text"), action.get("text_raw"), None
+
+        # Look up the parallel raw-template list emitted by the backend for
+        # this language. Same length as `chosen_list` at lowering time; if
+        # absent or short, the caller falls back to chosen_list itself
+        # (cache derivation will treat the rendered text as its own
+        # template — cache MAY miss but won't garble).
+        raw_variants = action.get("text_raw_variants")
+        raw_list: List[str] = []
+        if isinstance(raw_variants, dict):
+            cand_raw = raw_variants.get(chosen_lang or "")
+            if isinstance(cand_raw, list):
+                raw_list = [s for s in cand_raw if isinstance(s, str)]
 
         speak_id = (
             getattr(self._flow_manager, "_current_node", None)
@@ -465,6 +534,7 @@ class ActionManager:
         usage = self._flow_manager._variant_usage
         used = usage.get(usage_key, set())
         # Pick the smallest index not yet used; reset the set when full.
+        picked_idx = 0
         for idx in range(len(chosen_list)):
             if idx not in used:
                 used = set(used) | {idx}
@@ -472,11 +542,20 @@ class ActionManager:
                     usage[usage_key] = set()  # cycle complete; reset for next round
                 else:
                     usage[usage_key] = used
-                return chosen_list[idx]
-
-        # Degenerate: usage was already saturated (race) — reset and pick 0.
-        usage[usage_key] = {0}
-        return chosen_list[0]
+                picked_idx = idx
+                break
+        else:
+            # Degenerate: usage was already saturated (race) — reset and pick 0.
+            usage[usage_key] = {0}
+            picked_idx = 0
+
+        picked_text = chosen_list[picked_idx]
+        picked_raw = (
+            raw_list[picked_idx]
+            if 0 <= picked_idx < len(raw_list)
+            else picked_text
+        )
+        return picked_text, picked_raw, chosen_lang
 
     async def _maybe_switch_tts_service_for_action(self, action: dict) -> None:
         """Queue a :class:`ManuallySwitchServiceFrame` when the action carries
@@ -571,6 +650,9 @@ class ActionManager:
         self._ongoing_actions_count += 1
         if self._ongoing_actions_count == 1:
             self._ongoing_actions_finished_event.clear()
+        # Reset the interruption flag — any prior InterruptionFrame applied to
+        # the previous speech, not this new one.
+        self._seen_interruption_since_increment = False
 
     def _decrement_ongoing_actions_count(self) -> None:
         """Decrement the count of ongoing actions and set the finished event if this was the last action."""
@@ -590,3 +672,4 @@ class ActionManager:
             )
         self._ongoing_actions_count = 0
         self._ongoing_actions_finished_event.set()
+        self._seen_interruption_since_increment = False

{dv_pipecat_flows-0.0.22.dev1516 → dv_pipecat_flows-0.0.22.dev1700}/src/pipecat_flows/adapters.py

@@ -283,6 +283,138 @@ class UniversalLLMAdapter(LLMAdapter):
     be in the standard FlowsFunctionSchema format.
     """
 
+    async def run_router_completion(
+        self,
+        llm_service: Any,
+        system_prompt: str,
+        response_schema: Dict[str, Any],
+        context_messages: List[Dict[str, Any]],
+        *,
+        schema_name: str = "router_decision",
+    ) -> Optional[str]:
+        """Constrained completion for services using the universal LLMContext
+        (currently: ``OpenAIResponsesLLMService``).
+
+        Dispatches by underlying client surface:
+          * ``_client.responses`` (OpenAI Responses API) → ``responses.create``
+            with ``text.format = {type: json_schema, ...}``
+          * ``_client.chat.completions`` (any service exposing OpenAI's
+            chat-completions client — e.g. Azure when routed through universal
+            context) → falls back to OpenAI-style ``json_schema`` path.
+
+        Returns the raw JSON string, or None on failure.
+        """
+        if not hasattr(llm_service, "_client"):
+            logger.warning(
+                "Universal router completion: llm_service has no _client; "
+                "cannot make direct completion call"
+            )
+            return None
+
+        model_name = (
+            getattr(llm_service, "model_name", None)
+            or getattr(llm_service, "_model_name", None)
+            or getattr(llm_service, "_model", None)
+        )
+        if not model_name:
+            logger.warning(
+                f"Universal router completion: could not resolve model_name on "
+                f"{type(llm_service).__name__}; falling back to None."
+            )
+
+        client = llm_service._client
+
+        # Flatten context to a single input string for the Responses API. The
+        # Responses surface accepts a string for `input`; system_prompt goes
+        # into `instructions` separately so the model treats it as the
+        # authoritative directive (not just another user turn).
+        context_text = ""
+        if context_messages:
+            lines = []
+            for msg in context_messages:
+                role = msg.get("role", "user")
+                content = msg.get("content", "")
+                if isinstance(content, list):
+                    content = "".join(
+                        p.get("text", "") if isinstance(p, dict) else str(p)
+                        for p in content
+                    )
+                lines.append(f"{role}: {content}")
+            context_text = "\n".join(lines)
+
+        if hasattr(client, "responses"):
+            try:
+                response = await client.responses.create(
+                    model=model_name,
+                    input=context_text or " ",
+                    instructions=system_prompt,
+                    stream=False,
+                    text={
+                        "format": {
+                            "type": "json_schema",
+                            "name": schema_name,
+                            "schema": response_schema,
+                            "strict": True,
+                        }
+                    },
+                )
+                return getattr(response, "output_text", None)
+            except Exception as exc:  # noqa: BLE001
+                logger.error(
+                    f"Universal (Responses API) router completion failed: {exc!r}; "
+                    f"falling back to json_object"
+                )
+                try:
+                    response = await client.responses.create(
+                        model=model_name,
+                        input=context_text or " ",
+                        instructions=system_prompt,
+                        stream=False,
+                        text={"format": {"type": "json_object"}},
+                    )
+                    return getattr(response, "output_text", None)
+                except Exception as exc2:  # noqa: BLE001
+                    logger.error(
+                        f"Universal Responses fallback also failed: {exc2!r}"
+                    )
+                    return None
+
+        if hasattr(client, "chat") and hasattr(client.chat, "completions"):
+            # Service exposes the OpenAI chat-completions surface even though
+            # universal LLMContext is in use. Reuse the OpenAI-style path.
+            messages: List[Dict[str, Any]] = [
+                {"role": "system", "content": system_prompt}
+            ]
+            if context_messages:
+                messages.extend(context_messages)
+            try:
+                response = await client.chat.completions.create(
+                    model=model_name,
+                    messages=messages,
+                    temperature=0.1,
+                    response_format={
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": schema_name,
+                            "schema": response_schema,
+                            "strict": True,
+                        },
+                    },
+                )
+                return response.choices[0].message.content
+            except Exception as exc:  # noqa: BLE001
+                logger.error(
+                    f"Universal (chat-completions) router completion failed: {exc!r}"
+                )
+                return None
+
+        logger.warning(
+            f"Universal router completion: llm_service "
+            f"{type(llm_service).__name__} exposes neither responses nor "
+            f"chat.completions on its _client; no compatible structured-output path."
+        )
+        return None
+
     def _get_function_name_from_dict(self, function_def: Dict[str, Any]) -> str:
         raise RuntimeError(
             "Provider-specific function definitions are not supported in flows using universal LLMContext. Use FlowsFunctionSchemas or direct functions instead."
@@ -591,6 +723,119 @@ class GeminiAdapter(LLMAdapter):
     and Gemini's as needed.
     """
 
+    async def run_router_completion(
+        self,
+        llm_service: Any,
+        system_prompt: str,
+        response_schema: Dict[str, Any],
+        context_messages: List[Dict[str, Any]],
+        *,
+        schema_name: str = "router_decision",
+    ) -> Optional[str]:
+        """Gemini constrained completion via ``response_schema`` +
+        ``response_mime_type='application/json'``.
+
+        Accesses ``llm_service._client`` (google-genai SDK) and
+        ``llm_service._model_name``, makes a one-shot
+        ``generate_content`` outside the streaming pipeline. Returns the
+        raw JSON string emitted by the model.
+
+        Falls back to plain JSON mode (no schema) if the strict
+        ``response_schema`` path fails — Gemini's schema validator rejects
+        certain JSON Schema features that the universal router schema may
+        emit (e.g. nested ``oneOf`` / ``anyOf``).
+        """
+        if not hasattr(llm_service, "_client"):
+            logger.warning(
+                "Gemini router completion: llm_service has no _client; "
+                "cannot make direct completion call"
+            )
+            return None
+
+        model_name = (
+            getattr(llm_service, "model_name", None)
+            or getattr(llm_service, "_model_name", None)
+            or getattr(llm_service, "_model", None)
+        )
+        if not model_name:
+            logger.warning(
+                f"Gemini router completion: could not resolve model_name on "
+                f"{type(llm_service).__name__}; falling back to None."
+            )
+
+        # google-genai's GenerateContentConfig only ships with the optional
+        # `google` extra. Import lazily so non-Gemini deploys aren't forced
+        # to install google-genai.
+        try:
+            from google.genai.types import GenerateContentConfig
+        except ImportError:
+            logger.error(
+                "Gemini router completion: google-genai not installed; "
+                "install pipecat-ai[google] to use Router-LLM with Gemini."
+            )
+            return None
+
+        # Flatten context into a single user-turn string. Gemini's `contents`
+        # accepts Content objects with role+parts, but for a one-shot
+        # constrained completion a flat prompt is simpler and avoids the
+        # role-alternation requirement (system_instruction handles the system
+        # prompt separately).
+        context_text = ""
+        if context_messages:
+            lines = []
+            for msg in context_messages:
+                role = msg.get("role", "user")
+                content = msg.get("content", "")
+                if isinstance(content, list):
+                    content = "".join(
+                        p.get("text", "") if isinstance(p, dict) else str(p)
+                        for p in content
+                    )
+                lines.append(f"{role}: {content}")
+            context_text = "\n".join(lines)
+
+        try:
+            config = GenerateContentConfig(
+                system_instruction=system_prompt,
+                response_mime_type="application/json",
+                response_schema=response_schema,
+                temperature=0.1,
+            )
+            response = await llm_service._client.aio.models.generate_content(
+                model=model_name,
+                contents=context_text or " ",
+                config=config,
+            )
+            if response.candidates and response.candidates[0].content:
+                for part in response.candidates[0].content.parts:
+                    if part.text:
+                        return part.text
+            return None
+        except Exception as exc:  # noqa: BLE001
+            logger.error(
+                f"Gemini router completion failed: {exc!r}; "
+                f"falling back to JSON mode without schema"
+            )
+            try:
+                config = GenerateContentConfig(
+                    system_instruction=system_prompt,
+                    response_mime_type="application/json",
+                    temperature=0.1,
+                )
+                response = await llm_service._client.aio.models.generate_content(
+                    model=model_name,
+                    contents=context_text or " ",
+                    config=config,
+                )
+                if response.candidates and response.candidates[0].content:
+                    for part in response.candidates[0].content.parts:
+                        if part.text:
+                            return part.text
+                return None
+            except Exception as exc2:  # noqa: BLE001
+                logger.error(f"Gemini router completion fallback also failed: {exc2!r}")
+                return None
+
     def _get_function_name_from_dict(self, function_def: Dict[str, Any]) -> str:
         """Extract function name from Gemini function definition.
 

{dv_pipecat_flows-0.0.22.dev1516 → dv_pipecat_flows-0.0.22.dev1700}/src/pipecat_flows/condition_evaluator.py

@@ -25,6 +25,7 @@ Operator vocabulary (matches the FE's ConditionOperator set):
 
 Variable reference forms (matches the rest of the codebase):
     ``{{name}}``           -> custom/trigger variable, looked up in ``state``
+    ``[{name}]``           -> Router/Agent-extracted variable, looked up in ``state``
     ``((tool.field))``     -> pre-call tool output, looked up in ``tool_outputs``
                               (dotted path; first segment is the tool name,
                               remainder is jsonpath through its response)
@@ -59,6 +60,10 @@ _VALID_OPERATORS = frozenset({
 
 _BRACED_VAR_RE = re.compile(r"^\s*\{\{\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\}\}\s*$")
 _PAREN_VAR_RE = re.compile(r"^\s*\(\(\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\)\)\s*$")
+# ``[{name}]`` is the dedicated Router/Agent-extracted-variable token (kept
+# distinct from custom ``{{name}}`` on the FE). Resolves from ``state`` exactly
+# like the braced and bare forms.
+_BRACKET_BRACE_VAR_RE = re.compile(r"^\s*\[\{\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\}\]\s*$")
 
 
 def _walk_dotted(obj: Any, path: List[str]) -> Any:
@@ -119,6 +124,10 @@ def _resolve_variable(
             return None
         return _walk_dotted(tool_outputs, paren.group(1).split("."))
 
+    bracket_brace = _BRACKET_BRACE_VAR_RE.match(ref)
+    if bracket_brace:
+        return _walk_dotted(state, bracket_brace.group(1).split("."))
+
     # Bare identifier — treat as state lookup, allowing dotted paths.
     return _walk_dotted(state, ref.strip().split("."))