dv-pipecat-flows 0.0.0.dev2072__tar.gz → 0.0.0.dev2093__tar.gz

{dv_pipecat_flows-0.0.0.dev2072/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.0.dev2093}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.0.dev2072
+Version: 0.0.0.dev2093
 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.0.dev2072 → dv_pipecat_flows-0.0.0.dev2093/src/dv_pipecat_flows.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.0.dev2072
+Version: 0.0.0.dev2093
 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.0.dev2072 → dv_pipecat_flows-0.0.0.dev2093}/src/dv_pipecat_flows.egg-info/SOURCES.txt

@@ -101,7 +101,6 @@ src/pipecat_flows/__init__.py
 src/pipecat_flows/actions.py
 src/pipecat_flows/adapters.py
 src/pipecat_flows/condition_evaluator.py
-src/pipecat_flows/data_extractor.py
 src/pipecat_flows/exceptions.py
 src/pipecat_flows/flow_validator.py
 src/pipecat_flows/manager.py

{dv_pipecat_flows-0.0.0.dev2072 → dv_pipecat_flows-0.0.0.dev2093}/src/pipecat_flows/actions.py

@@ -312,11 +312,16 @@ class ActionManager:
 
         Args:
             action: Action configuration containing:
-                - text: Text to speak (required)
+                - text: Text to speak (required, resolved)
+                - text_raw: Raw template with {{var}} markers (optional)
                 - use_cache: Use caching for TTS audio (optional, default: False)
 
-        Note: Caching functionality must be provided via dependency injection through
-        flow_manager.state['say_with_cache_handler'] if use_cache=True.
+        Caching is opt-in via dependency injection: when use_cache=True and
+        flow_manager.state['say_with_cache_handler'] is set, the handler is
+        invoked as `await handler(text=..., text_raw=...) -> bool`. Returning
+        True means the handler served the audio downstream (and pushed an
+        ActionFinishedFrame downstream itself). Returning False (or raising)
+        falls back to live TTS via TTSSpeakFrame.
 
         To prevent the LLM from immediately responding after TTS in pre-actions,
         set respond_immediately=false in the node configuration.
@@ -327,18 +332,32 @@ class ActionManager:
             return
 
         use_cache = action.get("use_cache", False)
+        cache_handler = (
+            self._flow_manager.state.get("say_with_cache_handler") if use_cache else None
+        )
 
         try:
-            # For now, always use the standard TTS path to avoid pipeline issues
-            # Caching can be implemented at the TTS service level instead
-
             # Mark that we're starting the action
             self._increment_ongoing_actions_count()
 
-            # Queue the TTS frame
-            await self._task.queue_frame(TTSSpeakFrame(text=text))
-
-            # Queue frame marking the end of the action
+            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))
+                except Exception as e:
+                    logger.error(f"tts_say cache handler raised, falling back to live TTS: {e}")
+                    served_from_cache = False
+
+            if not served_from_cache:
+                # Live TTS path
+                await self._task.queue_frame(TTSSpeakFrame(text=text))
+
+            # Queue frame marking the end of the action. Even on the cached
+            # path this is safe: the frame is queued at the source and has to
+            # traverse the entire pipeline to reach our downstream filter,
+            # while the cached audio was pushed downstream of the TTS service
+            # and reaches the wire sooner.
             await self._task.queue_frame(ActionFinishedFrame())
 
         except Exception as e:

{dv_pipecat_flows-0.0.0.dev2072 → dv_pipecat_flows-0.0.0.dev2093}/src/pipecat_flows/adapters.py

@@ -176,9 +176,9 @@ class LLMAdapter:
 
         Args:
             llm_service: The underlying LLM service (exposes ``_client`` +
-                ``_model``, same convention as ``DataExtractor`` uses).
-            system_prompt: System message text (built by
-                :func:`render_router_system_prompt`).
+                ``_model``).
+            system_prompt: System message text (authored by the backend
+                lowerer and shipped via ``task_messages[0].content``).
             response_schema: JSON Schema constraining the output (built by
                 :func:`build_router_response_schema`).
             context_messages: Recent conversation turns to include as user
@@ -374,8 +374,7 @@ class OpenAIAdapter(LLMAdapter):
         """OpenAI / Azure constrained completion via ``response_format``
         ``json_schema``. Returns the raw JSON string emitted by the model.
 
-        Mirrors the direct-client pattern already used by ``DataExtractor``:
-        accesses ``llm_service._client`` and ``llm_service._model``, makes a
+        Accesses ``llm_service._client`` and ``llm_service._model``, makes a
         one-shot ``chat.completions.create`` outside the streaming pipeline.
 
         Uses ``strict: True`` so OpenAI enforces the schema server-side

{dv_pipecat_flows-0.0.0.dev2072 → dv_pipecat_flows-0.0.0.dev2093}/src/pipecat_flows/manager.py

@@ -68,7 +68,6 @@ from pipecat.transports.base_transport import BaseTransport
 from pipecat_flows.actions import ActionError, ActionManager
 from pipecat_flows.adapters import create_adapter
 from pipecat_flows.condition_evaluator import evaluate_conditions
-from pipecat_flows.data_extractor import DataExtractor
 from pipecat_flows.exceptions import (
     AutoTransitionDepthError,
     FlowError,
@@ -84,7 +83,6 @@ from pipecat_flows.router_mode import (
     build_router_response_schema,
     parse_router_response,
     pick_branch_target,
-    render_router_system_prompt,
 )
 from pipecat_flows.types import (
     ActionConfig,
@@ -175,8 +173,12 @@ class FlowManager:
         self._llm = llm
         self._action_manager = ActionManager(task, flow_manager=self)
         self._adapter = create_adapter(llm, context_aggregator)
-        self._data_extractor = DataExtractor()
         self._initialized = False
+        # Stashed by _run_router_node right after the LLM picks a branch and
+        # read by _set_node when it tool-logs the transition. Lets the router
+        # rationale + prompt_sha1 land in the transition tool-log args. Cleared
+        # by _set_node after read so it can't leak into an unrelated next hop.
+        self._last_router_pick: Optional[Dict[str, Any]] = None
         self._context_aggregator = context_aggregator
         self._pending_transition: Optional[Dict[str, Any]] = None
         self._pending_function_results: Dict[str, Dict[str, Any]] = {}  # Store function results for extraction
@@ -912,69 +914,6 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 )
         await self._set_node(node_id, node_config)
 
-    async def _process_data_extraction(self, node_id: str, node_config: NodeConfig) -> None:
-        """Process data extraction for the current node.
-
-        Args:
-            node_id: The current node ID
-            node_config: The node configuration containing extraction settings
-        """
-        # Get extraction config from runtime config or node config
-        runtime_config = self.state.get("nodes_runtime_config", {})
-        node_runtime = runtime_config.get(node_id, {})
-        extraction_config = node_runtime.get("data_extraction", [])
-
-        # Also check node_config directly if not in runtime
-        if not extraction_config and "data_extraction" in node_config:
-            extraction_config = node_config["data_extraction"]
-            # Convert to dict format if needed
-            if extraction_config and hasattr(extraction_config[0], "model_dump"):
-                extraction_config = [field.model_dump() for field in extraction_config]
-
-        if not extraction_config:
-            return
-
-        logger.debug(f"Processing data extraction for node {node_id}: {len(extraction_config)} fields")
-
-        try:
-            # Get conversation context for conversation-type extractions
-            conversation_context = None
-            has_conversation_fields = any(
-                f.get("extraction_type") == "conversation" for f in extraction_config
-            )
-            if has_conversation_fields:
-                try:
-                    conversation_context = self.get_current_context()
-                except Exception as e:
-                    logger.warning(f"Could not get conversation context for extraction: {e}")
-
-            # Process all extractions
-            extracted_data = await self._data_extractor.process_node_extractions(
-                node_name=node_id,
-                extraction_config=extraction_config,
-                function_results=self._pending_function_results.copy() if self._pending_function_results else None,
-                conversation_context=conversation_context,
-                llm_service=self._llm if has_conversation_fields else None,
-            )
-
-            # Store extracted data in state
-            if extracted_data:
-                if "extracted_data" not in self.state:
-                    self.state["extracted_data"] = {}
-                if node_id not in self.state["extracted_data"]:
-                    self.state["extracted_data"][node_id] = {}
-
-                self.state["extracted_data"][node_id].update(extracted_data)
-                logger.info(f"Stored {len(extracted_data)} extracted fields for node {node_id}")
-
-            # Clear pending function results after extraction
-            self._pending_function_results.clear()
-
-        except Exception as e:
-            logger.error(f"Error during data extraction for node {node_id}: {e}")
-            # Clear pending results even on error
-            self._pending_function_results.clear()
-
     # ------------------------------------------------------------------
     # Pure-code dispatch primitives (auto_transition + condition_evaluator).
     # Used by Speak / Action / Condition-Router to skip the LLM round-trip.
@@ -1144,11 +1083,11 @@ In all of these cases, you can provide a `name` in your new node's config for de
         if not self._context_aggregator or target_node_config is None:
             return False
         target_kind = target_node_config.get("type")
-        if target_kind in ("speak", "action"):
+        if target_kind in ("speak_node", "action_node"):
             return False
         is_terminal = bool(target_node_config.get("terminal")) or target_kind in (
             "end_node",
-            "transfer",
+            "transfer_node",
         )
         is_cond_router = target_node_config.get("auto_transition") == "__condition__"
         user_agg = self._context_aggregator.user()
@@ -1250,24 +1189,24 @@ In all of these cases, you can provide a `name` in your new node's config for de
 
         branches = node_config.get("router_branches") or []
         extract = node_config.get("router_extract") or {}
-        branch_descriptions = node_config.get("router_branch_descriptions") or {}
 
-        # Temporary diagnostic — answers "did router_branch_descriptions
-        # actually reach the engine, or is the lowerer/pydantic layer still
-        # silently dropping it?" Remove after verifying.
-        logger.debug(
-            f"Router '{node_id}' descriptions present={bool(branch_descriptions)} "
-            f"keys={list(branch_descriptions.keys())} "
-            f"sample={next(iter(branch_descriptions.items()), None)}"
+        # Backend lowerer is the single source of truth for the router prompt.
+        # It writes the rendered prompt into task_messages[0].content at publish
+        # time; we read it verbatim here. No runtime re-rendering — keeps prompt
+        # authoring in the backend repo and avoids drift between lowering-time
+        # and runtime prompts.
+        tm = node_config.get("task_messages") or []
+        system_prompt = (
+            tm[0].get("content", "") if tm and isinstance(tm[0], dict) else ""
         )
+        if not system_prompt:
+            raise RouterParseError(
+                f"router node '{node_id}' has no rendered system prompt in "
+                f"task_messages[0].content — re-publish the agent so the "
+                f"lowerer fills it"
+            )
 
         schema = build_router_response_schema(branches, extract)
-        system_prompt = render_router_system_prompt(
-            branches, extract, branch_descriptions
-        )
-        logger.debug(
-            f"Router '{node_id}' rendered system_prompt ({len(system_prompt)} chars):\n{system_prompt}"
-        )
         valid_branch_ids = [b["id"] for b in branches if isinstance(b, dict) and b.get("id")]
         valid_branch_ids.append(UNCLEAR_BRANCH_ID)
 
@@ -1340,6 +1279,13 @@ In all of these cases, you can provide a `name` in your new node's config for de
             f"Router '{node_id}' picked branch_id='{branch_id}' "
             f"rationale={rationale!r} prompt_sha1={prompt_hash}"
         )
+        # Hand off to the next _set_node so it can surface this in the
+        # transition tool-log args. Cleared by _set_node after read.
+        self._last_router_pick = {
+            "branch_id": branch_id,
+            "rationale": rationale,
+            "prompt_sha1": prompt_hash,
+        }
 
         # Write extracted variables into shared state so downstream nodes
         # (Condition routers, Speak template substitutions) can read them.
@@ -1595,6 +1541,32 @@ In all of these cases, you can provide a `name` in your new node's config for de
         if not self._initialized:
             raise FlowTransitionError(f"{self.__class__.__name__} must be initialized first")
 
+        # Tool-log every transition so operators see the graph traversal on
+        # the same timeline as on-call API tool calls. Capture state BEFORE
+        # any of the node-setup logic runs so previous_node_id reflects the
+        # actual outgoing node (legacy path resets _current_node only at L1796
+        # of the success arm; v2 paths early-latch at L1546).
+        transition_start_time = time.time()
+        previous_node_id = self._current_node
+        router_pick = self._last_router_pick
+        self._last_router_pick = None
+        transition_tool_name = f"transition_to_{node_id}"
+        transition_args: Dict[str, Any] = {
+            "from_node_id": previous_node_id,
+            "to_node_id": node_id,
+        }
+        if router_pick:
+            transition_args.update(router_pick)
+        transition_call_id = await start_tracking(
+            transcript_handler=getattr(self, "_transcript_handler", None),
+            tool_name=transition_tool_name,
+            args=transition_args,
+            tool_phase="on_call",
+            tool_type="transition",
+            current_node=previous_node_id,
+            logger=logger,
+        )
+
         try:
             # Clear any pending transition state when starting a new node
             # This ensures clean state regardless of how we arrived here:
@@ -1715,9 +1687,6 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # Apply node-level overrides if any
             await self._apply_node_overrides(node_id)
 
-            # Process data extraction for the node (function results from previous node)
-            await self._process_data_extraction(node_id, node_config)
-
             # Pure-code short-circuit: if this node is a Speak / Action /
             # Condition-Router (has `auto_transition`), skip tools+context+
             # LLMRunFrame entirely and recurse directly into the target node.
@@ -1886,6 +1855,19 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # node_entered observer is now emitted at the *top* of _set_node
             # so short-circuit paths (auto_transition / router-mode) get it too.
 
+            await complete_tracking(
+                transcript_handler=getattr(self, "_transcript_handler", None),
+                function_call_id=transition_call_id,
+                tool_name=transition_tool_name,
+                function_start_time=transition_start_time,
+                response_data={
+                    "to_node_id": node_id,
+                    "to_node_label": node_config.get("label"),
+                },
+                status_code=200,
+                logger=logger,
+            )
+
         except Exception as e:
             # If setup crashed inside an uninterruptible node, the guard is
             # still latched on ``_current_node`` — clear it so the pipeline
@@ -1896,6 +1878,19 @@ In all of these cases, you can provide a `name` in your new node's config for de
             except Exception:
                 pass
             logger.error(f"Error setting node {node_id}: {str(e)}")
+            try:
+                await complete_tracking(
+                    transcript_handler=getattr(self, "_transcript_handler", None),
+                    function_call_id=transition_call_id,
+                    tool_name=transition_tool_name,
+                    function_start_time=transition_start_time,
+                    response_data=None,
+                    status_code=500,
+                    error_details={"error": str(e), "type": type(e).__name__},
+                    logger=logger,
+                )
+            except Exception as track_exc:
+                logger.warning(f"complete_tracking failed for {transition_tool_name}: {track_exc!r}")
             raise FlowError(f"Failed to set node {node_id}: {str(e)}") from e
 
     def _schedule_deferred_post_actions(self, post_actions: List[ActionConfig]) -> None:

{dv_pipecat_flows-0.0.0.dev2072 → dv_pipecat_flows-0.0.0.dev2093}/src/pipecat_flows/router_mode.py

@@ -16,12 +16,15 @@ writes extracted variables into ``flow_manager.state``, and recurses into
 
 This module is the pure data-shaping layer:
     * :func:`build_router_response_schema` — JSON Schema for the constrained call
-    * :func:`render_router_system_prompt` — system message text for the call
     * :func:`parse_router_response` — extracts ``{branch, extracted}`` from a
       provider response (string/dict/tool-call), with defensive fallbacks
     * :func:`pick_branch_target` — resolves the parsed branch_id to a target
       node name (and handles the unclear sentinel + attempt counter)
 
+The router system prompt itself is authored by the backend lowerer
+(``new_calling_agent_backend/agent/commons/flow_lowering.py``) and shipped
+verbatim in ``task_messages[0].content``; the engine reads it directly.
+
 The actual LLM call orchestration lives in ``manager.py:_run_router_node`` —
 this module provides the helpers it composes.
 """
@@ -135,90 +138,6 @@ def build_router_response_schema(
     }
 
 
-def render_router_system_prompt(
-    branches: List[RouterBranch],
-    extract: Optional[Dict[str, ExtractSpec]] = None,
-    branch_descriptions: Optional[Dict[str, str]] = None,
-) -> str:
-    """Build the router's system message.
-
-    Kept short on purpose — every token here is paid on every router call (or
-    cached, if prompt-caching is wired). Lists each branch with its description
-    so the LLM knows when to pick which; appends the extract-vars block when
-    the node asks for any.
-
-    Args:
-        branches: NodeConfig ``router_branches`` list (carries id + next).
-        extract: NodeConfig ``router_extract`` map.
-        branch_descriptions: Optional override map ``{branch_id: description}``.
-            The backend lowerer pulls descriptions from the matching edges'
-            ``condition`` field, not from the branches list itself, so this
-            argument is how the orchestrator passes them in.
-
-    Returns:
-        System-prompt string. Engine appends the recent conversation turns
-        as a follow-on user message (see ``router_context_window``).
-    """
-    descriptions = branch_descriptions or {}
-    branch_lines: List[str] = []
-    for br in branches or []:
-        if not isinstance(br, dict):
-            continue
-        bid = br.get("id")
-        if not bid:
-            continue
-        desc = descriptions.get(bid) or "(no description)"
-        branch_lines.append(f"- {bid}: {desc}")
-    branch_lines.append(
-        f"- {UNCLEAR_BRANCH_ID}: pick this when no branch above clearly fits "
-        f"what the user said"
-    )
-
-    extract_block = ""
-    if extract:
-        extract_rows: List[str] = []
-        for name, spec in extract.items():
-            if not isinstance(spec, dict):
-                extract_rows.append(f"- {name} (string)")
-                continue
-            t = spec.get("type", "string")
-            desc = spec.get("description", "")
-            tail = f" ({t}) — {desc}" if desc else f" ({t})"
-            extract_rows.append(f"- {name}{tail}")
-        extract_block = (
-            "\n\n## Also extract these variables (use null if the user didn't say):\n"
-            + "\n".join(extract_rows)
-        )
-
-    reasoning_block = (
-        "\n\n## How to reason\n"
-        "Read the user's MOST RECENT message in full before picking. When it "
-        "contains BOTH a negation (\"no\", \"not\", \"don't\", \"won't\", "
-        "\"can't\", \"nahi\", \"nahin\") AND a positive-sounding action "
-        "statement — in either order — the negation scopes over the whole "
-        "message. Do NOT pick a positive branch just because one sub-clause "
-        "matches its description. Pick a negative-sense branch if one fits; "
-        "otherwise __unclear__.\n\n"
-        "Example: \"no I don't think so I'll be able to pay\" — negation at "
-        "the start scopes over \"I'll be able to pay\". Pick a "
-        "\"cannot pay\"-style branch if present, else __unclear__.\n\n"
-        "## Strong default\n"
-        "If the message is ambiguous or self-contradictory and you can't "
-        "defend your pick by quoting the user, prefer __unclear__. A reprompt "
-        "costs one turn; a confident misroute costs the call."
-    )
-
-    return (
-        "You are a branch-routing classifier for a conversational agent. Read "
-        "the conversation so far and pick the one branch_id that best matches "
-        "what the user said. Emit JSON with `rationale` first (1-2 sentences "
-        "citing the user's words), then `branch`, then `extracted`.\n\n"
-        "## Branches\n" + "\n".join(branch_lines)
-        + extract_block
-        + reasoning_block
-    )
-
-
 def parse_router_response(
     raw: Any,
     valid_branch_ids: List[str],

dv_pipecat_flows-0.0.0.dev2072/src/pipecat_flows/data_extractor.py

@@ -1,249 +0,0 @@
-#
-# Copyright (c) 2024, Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-"""Data extraction system for Pipecat Flows.
-
-This module provides functionality to extract and store data at the node level
-from either function responses or conversation context, making it available
-to downstream nodes through the flow manager's state.
-"""
-
-import json
-from typing import Any, Dict, List, Optional
-
-from loguru import logger
-from pipecat.frames.frames import LLMMessagesAppendFrame
-from pipecat.processors.aggregators.llm_context import LLMContext
-
-
-class DataExtractor:
-    """Handles extraction of data from function responses and conversations."""
-
-    def __init__(self):
-        """Initialize the data extractor."""
-        self._extraction_cache = {}
-
-    async def extract_from_function_response(
-        self,
-        function_name: str,
-        response: Dict[str, Any],
-        extraction_fields: List[Dict[str, Any]],
-    ) -> Dict[str, Any]:
-        """Store complete function response for specified fields.
-
-        Args:
-            function_name: Name of the function that produced the response.
-            response: The complete response from the function.
-            extraction_fields: List of extraction field configurations.
-
-        Returns:
-            Dictionary mapping field keys to extracted values.
-        """
-        extracted_data = {}
-
-        for field in extraction_fields:
-            if field.get("extraction_type") != "function_response":
-                continue
-
-            if field.get("source_function") != function_name:
-                continue
-
-            key = field.get("key")
-            if not key:
-                logger.warning(f"Extraction field missing 'key' for function {function_name}")
-                continue
-
-            # Store the complete response
-            extracted_data[key] = response
-            logger.debug(f"Extracted function response for key '{key}' from {function_name}")
-
-        return extracted_data
-
-    async def extract_from_conversation(
-        self,
-        context: List[Dict[str, Any]],
-        extraction_fields: List[Dict[str, Any]],
-        llm_service: Any,
-    ) -> Dict[str, Any]:
-        """Use LLM to extract data from conversation context.
-
-        Args:
-            context: The conversation context (list of messages).
-            extraction_fields: List of extraction field configurations.
-            llm_service: The LLM service to use for extraction.
-
-        Returns:
-            Dictionary mapping field keys to extracted values.
-        """
-        extracted_data = {}
-
-        # Filter for conversation-type extractions
-        conversation_fields = [
-            f for f in extraction_fields if f.get("extraction_type") == "conversation"
-        ]
-
-        if not conversation_fields:
-            return extracted_data
-
-        # Build extraction prompt
-        extraction_prompt = self._build_extraction_prompt(context, conversation_fields)
-
-        try:
-            # Create a temporary context for extraction
-            extraction_messages = [
-                {
-                    "role": "system",
-                    "content": "You are a data extraction assistant. Extract the requested information from the conversation and return it as JSON.",
-                },
-                {"role": "user", "content": extraction_prompt},
-            ]
-
-            # Use LLM to extract data
-            # Note: This assumes the LLM service has a method to get completions
-            # You may need to adjust based on your LLM service implementation
-            response = await self._get_llm_extraction(llm_service, extraction_messages)
-
-            if response:
-                try:
-                    # Parse the JSON response
-                    extracted = json.loads(response)
-                    for field in conversation_fields:
-                        key = field.get("key")
-                        if key and key in extracted:
-                            extracted_data[key] = extracted[key]
-                            logger.debug(f"Extracted conversation data for key '{key}'")
-                except json.JSONDecodeError as e:
-                    logger.error(f"Failed to parse LLM extraction response: {e}")
-                    # Try to extract raw values as fallback
-                    for field in conversation_fields:
-                        key = field.get("key")
-                        if key:
-                            extracted_data[key] = None
-
-        except Exception as e:
-            logger.error(f"Error during conversation extraction: {e}")
-            # Set all fields to None on error
-            for field in conversation_fields:
-                key = field.get("key")
-                if key:
-                    extracted_data[key] = None
-
-        return extracted_data
-
-    def _build_extraction_prompt(
-        self, context: List[Dict[str, Any]], fields: List[Dict[str, Any]]
-    ) -> str:
-        """Build a prompt for LLM extraction.
-
-        Args:
-            context: The conversation context.
-            fields: Fields to extract.
-
-        Returns:
-            The extraction prompt string.
-        """
-        # Format the conversation
-        conversation_text = "\n".join(
-            [f"{msg.get('role', 'unknown')}: {msg.get('content', '')}" for msg in context[-10:]]
-        )
-
-        # Build field descriptions
-        field_descriptions = []
-        for field in fields:
-            key = field.get("key")
-            description = field.get("description", f"Extract {key}")
-            field_descriptions.append(f"- {key}: {description}")
-
-        prompt = f"""Given the following conversation:
-
-{conversation_text}
-
-Please extract the following information and return it as a JSON object:
-{chr(10).join(field_descriptions)}
-
-Return only valid JSON with the extracted values. If a value cannot be determined, use null.
-"""
-        return prompt
-
-    async def _get_llm_extraction(
-        self, llm_service: Any, messages: List[Dict[str, Any]]
-    ) -> Optional[str]:
-        """Get extraction response from LLM.
-
-        This is a placeholder that needs to be adapted based on the specific
-        LLM service implementation.
-
-        Args:
-            llm_service: The LLM service instance.
-            messages: Messages to send to the LLM.
-
-        Returns:
-            The LLM response as a string, or None if failed.
-        """
-        try:
-            # This implementation depends on your LLM service
-            # For OpenAI-style services:
-            if hasattr(llm_service, "_client"):
-                # Assuming OpenAI-style client
-                response = await llm_service._client.chat.completions.create(
-                    model=llm_service._model,
-                    messages=messages,
-                    temperature=0.1,  # Low temperature for consistent extraction
-                    response_format={"type": "json_object"},  # Request JSON format
-                )
-                return response.choices[0].message.content
-            else:
-                logger.warning("LLM service does not support extraction, returning None")
-                return None
-        except Exception as e:
-            logger.error(f"Error calling LLM for extraction: {e}")
-            return None
-
-    async def process_node_extractions(
-        self,
-        node_name: str,
-        extraction_config: List[Dict[str, Any]],
-        function_results: Optional[Dict[str, Dict[str, Any]]] = None,
-        conversation_context: Optional[List[Dict[str, Any]]] = None,
-        llm_service: Optional[Any] = None,
-    ) -> Dict[str, Any]:
-        """Process all data extractions for a node.
-
-        Args:
-            node_name: Name of the current node.
-            extraction_config: List of extraction field configurations.
-            function_results: Map of function names to their results.
-            conversation_context: The conversation context.
-            llm_service: The LLM service for conversation extraction.
-
-        Returns:
-            Dictionary with all extracted data for the node.
-        """
-        if not extraction_config:
-            return {}
-
-        all_extracted = {}
-
-        # Process function response extractions
-        if function_results:
-            for func_name, result in function_results.items():
-                func_extracted = await self.extract_from_function_response(
-                    func_name, result, extraction_config
-                )
-                all_extracted.update(func_extracted)
-
-        # Process conversation extractions
-        if conversation_context and llm_service:
-            conv_extracted = await self.extract_from_conversation(
-                conversation_context, extraction_config, llm_service
-            )
-            all_extracted.update(conv_extracted)
-
-        if all_extracted:
-            logger.info(
-                f"Extracted {len(all_extracted)} data fields for node '{node_name}': {list(all_extracted.keys())}"
-            )
-
-        return all_extracted