feat: add AWS Bedrock support

api/services/workflow/dto.py

@@ -53,6 +53,7 @@ class NodeDataDTO(BaseModel):
     extraction_prompt: Optional[str] = None
     extraction_variables: Optional[list[ExtractionVariableDTO]] = None
     add_global_prompt: bool = True
+    greeting: Optional[str] = None
     wait_for_user_response: bool = False
     wait_for_user_response_timeout: Optional[float] = None
     detect_voicemail: bool = False

api/services/workflow/pipecat_engine.py

@@ -554,6 +554,13 @@ class PipecatEngine:
             # Setup LLM Context with Prompts and Functions
             await self._setup_llm_context(node)
 
+    def get_start_greeting(self) -> Optional[str]:
+        """Return the rendered greeting for the start node, or None if not configured."""
+        start_node = self.workflow.nodes.get(self.workflow.start_node_id)
+        if start_node and start_node.greeting:
+            return self._format_prompt(start_node.greeting)
+        return None
+
     async def _handle_end_node(self, node: Node) -> None:
         """Handle end node execution."""
         if node.is_static:

api/services/workflow/qa/analysis.py

@@ -4,19 +4,16 @@ import json
 from typing import Any
 
 from loguru import logger
-from openai import AsyncOpenAI
 
 from api.db.models import WorkflowRunModel
 from api.services.gen_ai.json_parser import parse_llm_json
+from api.services.pipecat.service_factory import create_llm_service_from_provider
 from api.services.workflow.qa.conversation import (
     build_conversation_structure,
     format_transcript,
     split_events_by_node,
 )
-from api.services.workflow.qa.llm_config import (
-    accumulate_token_usage,
-    resolve_llm_config,
-)
+from api.services.workflow.qa.llm_config import resolve_llm_config
 from api.services.workflow.qa.metrics import compute_call_metrics
 from api.services.workflow.qa.node_summary import (
     CONVERSATION_SUMMARY_SYSTEM_PROMPT,
@@ -28,15 +25,22 @@ from api.services.workflow.qa.tracing import (
     setup_langfuse_parent_context,
 )
 from api.utils.template_renderer import render_template
+from pipecat.processors.aggregators.llm_context import LLMContext
+
+
+async def _run_llm_inference(llm, messages: list[dict]) -> str | None:
+    """Run a one-shot LLM inference using the pipecat service."""
+    context = LLMContext()
+    context.set_messages(messages)
+    return await llm.run_inference(context)
 
 
 async def _generate_conversation_summary(
-    client: AsyncOpenAI,
+    llm,
     model: str,
     transcript: str,
     parent_ctx,
     node_name: str,
-    total_token_usage: dict,
 ) -> str:
     """Generate a summary of the conversation so far (before the current node).
 
@@ -48,13 +52,7 @@ async def _generate_conversation_summary(
     ]
 
     try:
-        response = await client.chat.completions.create(
-            model=model,
-            messages=messages,
-            temperature=0,
-        )
-        summary = response.choices[0].message.content or ""
-        accumulate_token_usage(total_token_usage, response)
+        summary = await _run_llm_inference(llm, messages) or ""
 
         span_name = f"conversation-summary-before-{node_name}"
         add_qa_span_to_trace(parent_ctx, model, messages, summary, span_name)
@@ -82,7 +80,7 @@ async def run_per_node_qa_analysis(
     Falls back to whole-call QA if events lack node_id.
 
     Returns:
-        Dict with node_results, token_usage, model
+        Dict with node_results, model
     """
     logs = workflow_run.logs or {}
     rtf_events = logs.get("realtime_feedback_events", [])
@@ -107,7 +105,9 @@ async def run_per_node_qa_analysis(
         return {"error": "no_system_prompt", "node_results": {}}
 
     # Resolve LLM config
-    model, api_key, base_url = await resolve_llm_config(qa_node_data, workflow_run)
+    provider, model, api_key, service_kwargs = await resolve_llm_config(
+        qa_node_data, workflow_run
+    )
     if not api_key:
         logger.warning(
             f"No LLM API key configured for QA analysis on run {workflow_run_id}"
@@ -122,13 +122,9 @@ async def run_per_node_qa_analysis(
     # Set up Langfuse tracing
     parent_ctx = setup_langfuse_parent_context(workflow_run)
 
-    # Build LLM client
-    client_kwargs: dict[str, Any] = {"api_key": api_key}
-    if base_url:
-        client_kwargs["base_url"] = base_url
-    client = AsyncOpenAI(**client_kwargs)
+    # Build LLM service
+    llm = create_llm_service_from_provider(provider, model, api_key, **service_kwargs)
 
-    total_token_usage: dict[str, int] = {}
     node_results: dict[str, Any] = {}
     prior_conversation: list[dict] = []  # Running accumulation of all prior nodes
 
@@ -150,12 +146,11 @@ async def run_per_node_qa_analysis(
         if idx > 0 and prior_conversation:
             prior_transcript = format_transcript(prior_conversation)
             previous_conversation_summary = await _generate_conversation_summary(
-                client,
+                llm,
                 model,
                 prior_transcript,
                 parent_ctx,
                 node_name,
-                total_token_usage,
             )
 
         # Substitute placeholders in the user's system prompt
@@ -174,14 +169,7 @@ async def run_per_node_qa_analysis(
 
         # Call QA LLM
         try:
-            response = await client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=0,
-                extra_body={"stream": False},
-            )
-            raw_response = response.choices[0].message.content
-            accumulate_token_usage(total_token_usage, response)
+            raw_response = await _run_llm_inference(llm, messages)
         except Exception as e:
             logger.error(
                 f"QA LLM call failed for node '{node_name}' on run {workflow_run_id}: {e}"
@@ -221,13 +209,10 @@ async def run_per_node_qa_analysis(
         # Append this node's conversation to running total
         prior_conversation.extend(node_conversation)
 
-    result: dict[str, Any] = {
+    return {
         "node_results": node_results,
         "model": model,
     }
-    if total_token_usage:
-        result["token_usage"] = total_token_usage
-    return result
 
 
 async def _run_whole_call_qa_analysis(
@@ -262,7 +247,9 @@ async def _run_whole_call_qa_analysis(
         logger.warning("No system prompt defined for QA Node")
         return {"error": "no_system_prompt", "node_results": {}}
 
-    model, api_key, base_url = await resolve_llm_config(qa_node_data, workflow_run)
+    provider, model, api_key, service_kwargs = await resolve_llm_config(
+        qa_node_data, workflow_run
+    )
 
     if not api_key:
         logger.warning(
@@ -284,27 +271,14 @@ async def _run_whole_call_qa_analysis(
     ]
 
     # Call LLM
-    client_kwargs: dict[str, Any] = {"api_key": api_key}
-    if base_url:
-        client_kwargs["base_url"] = base_url
-
-    client = AsyncOpenAI(**client_kwargs)
+    llm = create_llm_service_from_provider(provider, model, api_key, **service_kwargs)
 
     try:
-        response = await client.chat.completions.create(
-            model=model,
-            messages=messages,
-            temperature=0,
-        )
-        raw_response = response.choices[0].message.content
+        raw_response = await _run_llm_inference(llm, messages)
     except Exception as e:
         logger.error(f"QA LLM call failed for run {workflow_run_id}: {e}")
         return {"error": str(e), "node_results": {}}
 
-    # Extract token usage
-    token_usage: dict[str, int] = {}
-    accumulate_token_usage(token_usage, response)
-
     # Parse response
     node_result: dict[str, Any] = {
         "node_name": "whole_call",
@@ -325,10 +299,7 @@ async def _run_whole_call_qa_analysis(
     parent_ctx = setup_langfuse_parent_context(workflow_run)
     add_qa_span_to_trace(parent_ctx, model, messages, raw_response, "qa-analysis")
 
-    result: dict[str, Any] = {
+    return {
         "node_results": {"whole_call": node_result},
         "model": model,
     }
-    if token_usage:
-        result["token_usage"] = token_usage
-    return result

api/services/workflow/qa/llm_config.py

@@ -1,63 +1,50 @@
 """LLM configuration resolution and token usage accumulation."""
 
-from api.constants import MPS_API_URL
 from api.db import db_client
 from api.db.models import WorkflowRunModel
 
 
-def _provider_base_url(provider: str | None, endpoint: str = "") -> str | None:
-    """Return the base URL for a given LLM provider."""
-    if provider == "openrouter":
-        return "https://openrouter.ai/api/v1"
-    if provider == "groq":
-        return "https://api.groq.com/openai/v1"
-    if provider == "google":
-        return "https://generativelanguage.googleapis.com/v1beta/openai/"
-    if provider == "azure":
-        return endpoint or None
-    if provider == "dograh":
-        return f"{MPS_API_URL}/api/v1/llm"
-    return None
-
-
 async def resolve_llm_config(
     qa_node_data: dict, workflow_run: WorkflowRunModel
-) -> tuple[str, str, str | None]:
-    """Resolve the LLM model, API key, and base URL for QA analysis.
+) -> tuple[str, str, str, dict]:
+    """Resolve the LLM provider, model, API key, and extra kwargs for QA analysis.
 
     If the QA node has its own LLM configuration (qa_use_workflow_llm=False),
     use those settings directly. Otherwise, fall back to the user's configured LLM.
 
     Returns:
-        (model, api_key, base_url) tuple
+        (provider, model, api_key, service_kwargs) tuple — service_kwargs can be
+        passed directly to create_llm_service_from_provider as keyword arguments.
     """
     if not qa_node_data.get("qa_use_workflow_llm", True):
+        provider = qa_node_data.get("qa_provider", "openai")
+        kwargs = {}
+        if provider == "azure":
+            kwargs["endpoint"] = qa_node_data.get("qa_endpoint", "")
         return (
+            provider,
             qa_node_data.get("qa_model"),
             qa_node_data.get("qa_api_key"),
-            _provider_base_url(
-                qa_node_data.get("qa_provider"),
-                qa_node_data.get("qa_endpoint", ""),
-            ),
+            kwargs,
         )
 
     # Fall back to user's configured LLM
-    model, api_key, base_url = await resolve_user_llm_config(workflow_run)
+    provider, model, api_key, kwargs = await resolve_user_llm_config(workflow_run)
 
     qa_model = qa_node_data.get("qa_model", "default")
     if qa_model and qa_model != "default":
         model = qa_model
 
-    return model, api_key, base_url
+    return provider, model, api_key, kwargs
 
 
 async def resolve_user_llm_config(
     workflow_run: WorkflowRunModel,
-) -> tuple[str, str, str | None]:
+) -> tuple[str, str, str, dict]:
     """Resolve the user's configured LLM (from UserConfiguration).
 
     Returns:
-        (model, api_key, base_url) tuple
+        (provider, model, api_key, service_kwargs) tuple
     """
     user_id = None
     if workflow_run.workflow and workflow_run.workflow.user:
@@ -71,11 +58,14 @@ async def resolve_user_llm_config(
     provider = llm_config.get("provider", "openai")
     api_key = llm_config.get("api_key", "")
     model = llm_config.get("model", "gpt-4.1")
-    base_url = _provider_base_url(provider, llm_config.get("endpoint", ""))
-    if provider == "openrouter" and llm_config.get("base_url"):
-        base_url = llm_config["base_url"]
 
-    return model, api_key, base_url
+    kwargs = {}
+    if provider == "azure":
+        kwargs["endpoint"] = llm_config.get("endpoint", "")
+    elif provider == "openrouter" and llm_config.get("base_url"):
+        kwargs["base_url"] = llm_config["base_url"]
+
+    return provider, model, api_key, kwargs
 
 
 def accumulate_token_usage(total: dict, response) -> None:

api/services/workflow/qa/node_summary.py

@@ -3,13 +3,14 @@
 from typing import Any
 
 from loguru import logger
-from openai import AsyncOpenAI
 
 from api.db import db_client
 from api.db.models import WorkflowRunModel
+from api.services.pipecat.service_factory import create_llm_service_from_provider
 from api.services.workflow.dto import NodeType
 from api.services.workflow.qa.llm_config import resolve_llm_config
 from api.services.workflow.qa.tracing import create_node_summary_trace
+from pipecat.processors.aggregators.llm_context import LLMContext
 
 NODE_SUMMARY_SYSTEM_PROMPT = (
     "You are analyzing a voice AI agent script. This is only a part of a larger script. "
@@ -67,15 +68,14 @@ async def ensure_node_summaries(
     if not nodes_needing_summary:
         return existing_summaries
 
-    model, api_key, base_url = await resolve_llm_config(qa_node_data, workflow_run)
+    provider, model, api_key, service_kwargs = await resolve_llm_config(
+        qa_node_data, workflow_run
+    )
     if not api_key:
         logger.warning("No API key for node summary generation, skipping")
         return existing_summaries
 
-    client_kwargs: dict[str, Any] = {"api_key": api_key}
-    if base_url:
-        client_kwargs["base_url"] = base_url
-    client = AsyncOpenAI(**client_kwargs)
+    llm = create_llm_service_from_provider(provider, model, api_key, **service_kwargs)
 
     updated_summaries = dict(existing_summaries)
 
@@ -153,12 +153,9 @@ async def ensure_node_summaries(
         ]
 
         try:
-            response = await client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=0,
-            )
-            summary_text = response.choices[0].message.content or ""
+            context = LLMContext()
+            context.set_messages(messages)
+            summary_text = await llm.run_inference(context) or ""
         except Exception as e:
             logger.warning(f"Failed to generate summary for node {node_id}: {e}")
             updated_summaries[node_id] = {"summary": ""}

api/services/workflow/workflow.py

@@ -45,6 +45,7 @@ class Node:
         self.extraction_prompt = data.extraction_prompt
         self.extraction_variables = data.extraction_variables
         self.add_global_prompt = data.add_global_prompt
+        self.greeting = data.greeting
         self.detect_voicemail = data.detect_voicemail
         self.delayed_start = data.delayed_start
         self.delayed_start_duration = data.delayed_start_duration