dv-pipecat-flows 0.0.23.dev8__tar.gz → 0.0.23.dev9__tar.gz

{dv_pipecat_flows-0.0.23.dev8/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.23.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.23.dev8
+Version: 0.0.23.dev9
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows

{dv_pipecat_flows-0.0.23.dev8 → dv_pipecat_flows-0.0.23.dev9/src/dv_pipecat_flows.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.23.dev8
+Version: 0.0.23.dev9
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows

{dv_pipecat_flows-0.0.23.dev8 → dv_pipecat_flows-0.0.23.dev9}/src/pipecat_flows/actions.py

@@ -71,6 +71,42 @@ ONGOING_ACTIONS_WAIT_TIMEOUT_S = 60.0
 _EXTRACT_VAR_RE = re.compile(
     r"@?\[\{\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\}\]"
 )
+# Whole string is exactly ONE token (``[{x}]`` / ``@[{x}]``, no surrounding
+# text). Callers that want to preserve a resolved list/dict value rather than
+# stringify it (e.g. chaining a JSON array into a later webhook body) match on
+# this and use ``resolve_extract_path`` directly.
+_EXACT_EXTRACT_RE = re.compile(
+    r"^@?\[\{\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\}\]$"
+)
+
+
+def resolve_extract_path(state: dict, key: str):
+    """Walk a dotted ``a.b.0.c`` path through nested dicts/lists in ``state``.
+
+    Numeric segments index lists (an Action node's stored response is often a
+    root array). Returns ``None`` on any missing/out-of-range segment.
+    """
+    cur = state
+    for seg in key.split("."):
+        if isinstance(cur, dict) and seg in cur:
+            cur = cur[seg]
+        elif isinstance(cur, list):
+            try:
+                cur = cur[int(seg)]
+            except (ValueError, IndexError, TypeError):
+                return None
+        else:
+            return None
+    return cur
+
+
+def exact_extract_key(text: str):
+    """Return the inner dotted key iff ``text`` is exactly one extract token
+    (``[{a.b}]`` / ``@[{a.b}]``), else ``None``. Whitespace-tolerant."""
+    if not isinstance(text, str):
+        return None
+    match = _EXACT_EXTRACT_RE.match(text.strip())
+    return match.group(1) if match else None
 
 
 def substitute_extract_vars(text: str, state: dict) -> str:
@@ -79,25 +115,17 @@ def substitute_extract_vars(text: str, state: dict) -> str:
     Supports dotted paths (``[{user.name}]``). Unknown variables (key not
     in state, or any path segment missing) are LEFT LITERAL — the marker
     survives so downstream debugging can spot the misconfigured extract.
+
+    Always returns a STRING (values are ``str()``-ified) — this is the
+    TTS/text-interpolation path. Callers needing to preserve a resolved
+    list/dict (e.g. a JSON webhook body value that is exactly one token)
+    should special-case ``exact_extract_key`` + ``resolve_extract_path``.
     """
     if not text or "[{" not in text or not isinstance(state, dict):
         return text
 
     def _resolve(key: str):
-        cur = state
-        for seg in key.split("."):
-            if isinstance(cur, dict) and seg in cur:
-                cur = cur[seg]
-            elif isinstance(cur, list):
-                # Numeric segment indexes a list — an Action node's stored
-                # response is often a root array (``[{action_1.0.title}]``).
-                try:
-                    cur = cur[int(seg)]
-                except (ValueError, IndexError, TypeError):
-                    return None
-            else:
-                return None
-        return cur
+        return resolve_extract_path(state, key)
 
     def _repl(match: "re.Match[str]") -> str:
         value = _resolve(match.group(1))