aiqtoolkit 1.1.0a20250429__py3-none-any.whl → 1.1.0a20250501__py3-none-any.whl

aiq/data_models/component_ref.py

@@ -43,7 +43,7 @@ class ComponentRefNode(HashableBaseModel):
 
     Args:
         ref_name (ComponentRef): The name of the component runtime instance.
-        component_group (ComponentGroup): The component group in an AgentIQ configuration object.
+        component_group (ComponentGroup): The component group in an AIQ Toolkit configuration object.
     """
 
     ref_name: "ComponentRef"
@@ -70,7 +70,7 @@ class ComponentRef(str, ABC):
         """Provides the component group this ComponentRef object represents.
 
         Returns:
-            ComponentGroup: A component group of the AgentIQ configuration object
+            ComponentGroup: A component group of the AIQ Toolkit configuration object
         """
 
         pass
@@ -82,7 +82,7 @@ class ComponentRef(str, ABC):
 
 class EmbedderRef(ComponentRef):
     """
-    A reference to an embedder in an AgentIQ configuration object.
+    A reference to an embedder in an AIQ Toolkit configuration object.
     """
 
     @property
@@ -93,7 +93,7 @@ class EmbedderRef(ComponentRef):
 
 class FunctionRef(ComponentRef):
     """
-    A reference to a function in an AgentIQ configuration object.
+    A reference to a function in an AIQ Toolkit configuration object.
     """
 
     @property
@@ -104,7 +104,7 @@ class FunctionRef(ComponentRef):
 
 class LLMRef(ComponentRef):
     """
-    A reference to an LLM in an AgentIQ configuration object.
+    A reference to an LLM in an AIQ Toolkit configuration object.
     """
 
     @property
@@ -115,7 +115,7 @@ class LLMRef(ComponentRef):
 
 class MemoryRef(ComponentRef):
     """
-    A reference to a memory in an AgentIQ configuration object.
+    A reference to a memory in an AIQ Toolkit configuration object.
     """
 
     @property
@@ -126,7 +126,7 @@ class MemoryRef(ComponentRef):
 
 class RetrieverRef(ComponentRef):
     """
-    A reference to a retriever in an AgentIQ configuration object.
+    A reference to a retriever in an AIQ Toolkit configuration object.
     """
 
     @property

aiq/data_models/discovery_metadata.py

@@ -55,11 +55,11 @@ class DiscoveryMetadata(BaseModel):
     """A data model representing metadata about each registered component to faciliate its discovery.
 
     Args:
-        package (str): The name of the package containing the AgentIQ component.
-        version (str): The version number of the package containing the AgentIQ component.
-        component_type (AIQComponentEnum): The type of AgentIQ component this metadata represents.
-        component_name (str): The registered name of the AgentIQ component.
-        description (str): Description of the AgentIQ component pulled from its config objects docstrings.
+        package (str): The name of the package containing the AIQ Toolkit component.
+        version (str): The version number of the package containing the AIQ Toolkit component.
+        component_type (AIQComponentEnum): The type of AIQ Toolkit component this metadata represents.
+        component_name (str): The registered name of the AIQ Toolkit component.
+        description (str): Description of the AIQ Toolkit component pulled from its config objects docstrings.
         developer_notes (str): Other notes to a developers to aid in the use of the component.
         status (DiscoveryStatusEnum): Provides the status of the metadata discovery process.
     """
@@ -129,7 +129,7 @@ class DiscoveryMetadata(BaseModel):
     @staticmethod
     def from_config_type(config_type: type["TypedBaseModelT"],
                          component_type: AIQComponentEnum = AIQComponentEnum.UNDEFINED) -> "DiscoveryMetadata":
-        """Generates discovery metadata from an AgentIQ config object.
+        """Generates discovery metadata from an AIQ Toolkit config object.
 
         Args:
             config_type (type[TypedBaseModelT]): A registered component's configuration object.
@@ -204,7 +204,7 @@ class DiscoveryMetadata(BaseModel):
         """Generates discovery metadata from an installed package name.
 
         Args:
-            package_name (str): The name of the AgentIQ plugin package containing registered components.
+            package_name (str): The name of the AIQ Toolkit plugin package containing registered components.
             package_version (str, optional): The version of the package, Defaults to None.
 
         Returns:

aiq/data_models/intermediate_step.py

@@ -98,7 +98,7 @@ class TraceMetadata(BaseModel):
 
 class IntermediateStepPayload(BaseModel):
     """
-    AIQIntermediateStep is a data model that represents an intermediate step in the AgentIQ. Intermediate steps are
+    AIQIntermediateStep is a data model that represents an intermediate step in the AIQ Toolkit. Intermediate steps are
     captured while a request is running and can be used to show progress or to evaluate the path a workflow took to get
     a response.
     """
@@ -203,7 +203,7 @@ class IntermediateStepPayload(BaseModel):
 
 class IntermediateStep(BaseModel):
     """
-    AIQIntermediateStep is a data model that represents an intermediate step in the AgentIQ. Intermediate steps are
+    AIQIntermediateStep is a data model that represents an intermediate step in the AIQ Toolkit. Intermediate steps are
     captured while a request is running and can be used to show progress or to evaluate the path a workflow took to get
     a response.
     """

aiq/eval/register.py

@@ -20,3 +20,4 @@
 from .rag_evaluator.register import register_ragas_evaluator
 from .swe_bench_evaluator.register import register_swe_bench_evaluator
 from .trajectory_evaluator.register import register_trajectory_evaluator
+from .tunable_rag_evaluator.register import register_tunable_rag_evaluator

aiq/eval/remote_workflow.py

@@ -52,7 +52,7 @@ class EvaluationRemoteWorkflowHandler:
 
         try:
             # Use the streaming endpoint
-            endpoint = f"{self.config.endpoint}/generate/stream/full"
+            endpoint = f"{self.config.endpoint}/generate/full"
             async with session.post(endpoint, json=payload) as response:
                 response.raise_for_status()  # Raise an exception for HTTP errors
 

aiq/eval/tunable_rag_evaluator/evaluate.py

@@ -0,0 +1,263 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import logging
+
+from langchain.output_parsers import ResponseSchema
+from langchain.output_parsers import StructuredOutputParser
+from langchain.schema import HumanMessage
+from langchain.schema import SystemMessage
+from langchain_core.language_models import BaseChatModel
+from tqdm import tqdm
+
+from aiq.eval.evaluator.evaluator_model import EvalInput
+from aiq.eval.evaluator.evaluator_model import EvalInputItem
+from aiq.eval.evaluator.evaluator_model import EvalOutput
+from aiq.eval.evaluator.evaluator_model import EvalOutputItem
+from aiq.eval.utils.tqdm_position_registry import TqdmPositionRegistry
+
+logger = logging.getLogger(__name__)
+
+# pylint: disable=line-too-long
+# flake8: noqa: E501
+
+
+def evaluation_prompt(judge_llm_prompt: str,
+                      question: str,
+                      answer_description: str,
+                      generated_answer: str,
+                      format_instructions: str,
+                      default_scoring: bool):
+    """
+    This function generates a prompt for the judge LLM to evaluate the generated answer.
+    """
+
+    DEFAULT_SCORING_INSTRUCTIONS = """
+    The coverage score is a measure of how well the generated answer covers the critical aspects mentioned in the expected answer. A low coverage score indicates that the generated answer misses critical aspects of the expected answer. A middle coverage score indicates that the generated answer covers some of the must-haves of the expected answer but lacks other details. A high coverage score indicates that all of the expected aspects are present in the generated answer.
+    The correctness score is a measure of how well the generated answer matches the expected answer. A low correctness score indicates that the generated answer is incorrect or does not match the expected answer. A middle correctness score indicates that the generated answer is correct but lacks some details. A high correctness score indicates that the generated answer is exactly the same as the expected answer.
+    The relevance score is a measure of how well the generated answer is relevant to the question. A low relevance score indicates that the generated answer is not relevant to the question. A middle relevance score indicates that the generated answer is somewhat relevant to the question. A high relevance score indicates that the generated answer is exactly relevant to the question.
+    The reasoning is a 1-2 sentence explanation for the scoring.
+    """
+
+    DEFAULT_EVAL_PROMPT = (f"You are an intelligent assistant that responds strictly in JSON format."
+                           f"Judge based on the following scoring rubric: {DEFAULT_SCORING_INSTRUCTIONS}"
+                           f"{judge_llm_prompt}\n"
+                           f"{format_instructions}\n"
+                           f"Here is the user's query: {question}"
+                           f"Here is the description of the expected answer: {answer_description}"
+                           f"Here is the generated answer: {generated_answer}")
+
+    EVAL_PROMPT = (f"You are an intelligent assistant that responds strictly in JSON format. {judge_llm_prompt}\n"
+                   f"{format_instructions}\n"
+                   f"Here is the user's query: {question}"
+                   f"Here is the description of the expected answer: {answer_description}"
+                   f"Here is the generated answer: {generated_answer}")
+
+    return EVAL_PROMPT if not default_scoring else DEFAULT_EVAL_PROMPT
+
+
+class TunableRagEvaluator:
+    '''Tunable RAG evaluator class with customizable LLM prompt for scoring.'''
+
+    def __init__(self,
+                 llm: BaseChatModel,
+                 judge_llm_prompt: str,
+                 max_concurrency: int,
+                 default_scoring: bool,
+                 default_score_weights: dict):
+        self.llm = llm
+        self.max_concurrency = max_concurrency
+        self.judge_llm_prompt = judge_llm_prompt
+        self.semaphore = asyncio.Semaphore(self.max_concurrency)
+        self.default_scoring = default_scoring
+        # Use user-provided weights if available; otherwise, set equal weights for each score
+        self.default_score_weights = default_score_weights if default_score_weights else {
+            "coverage": 1 / 3, "correctness": 1 / 3, "relevance": 1 / 3
+        }
+
+    async def evaluate(self, eval_input: EvalInput) -> EvalOutput:
+        '''Evaluate function'''
+
+        async def process_item(item):
+            """Compute RAG evaluation for an individual item"""
+            question = item.input_obj
+            answer_description = item.expected_output_obj
+            generated_answer = item.output_obj
+
+            # Call judge LLM to generate score
+            score = 0.0
+
+            default_evaluation_schema = [
+                ResponseSchema(
+                    name="coverage_score",
+                    description=
+                    "Score for the coverage of all critical aspects mentioned in the expected answer. Ex. 0.5",
+                    type="float"),
+                ResponseSchema(
+                    name="correctness_score",
+                    description=
+                    "Score for the accuracy of the generated answer compared to the expected answer. Ex. 0.5",
+                    type="float"),
+                ResponseSchema(name="relevance_score",
+                               description="Score for the relevance of the generated answer to the question. Ex. 0.5",
+                               type="float"),
+                ResponseSchema(
+                    name="reasoning",
+                    description=
+                    "1-2 summarized sentences of reasoning for the scores. Ex. 'The generated answer covers all critical aspects mentioned in the expected answer, is correct, and is relevant to the question.'",
+                    type="string"),
+            ]
+
+            custom_evaluation_schema = [
+                ResponseSchema(name="score", description="Score for the generated answer. Ex. 0.5", type="float"),
+                ResponseSchema(
+                    name="reasoning",
+                    description=
+                    "1-2 sentence reasoning for the score. Ex. 'The generated answer is exactly the same as the description of the expected answer.'",
+                    type="string"),
+            ]
+
+            if self.default_scoring:
+                evaluation_schema = default_evaluation_schema
+            else:
+                evaluation_schema = custom_evaluation_schema
+
+            llm_input_response_parser = StructuredOutputParser.from_response_schemas(evaluation_schema)
+            format_instructions = llm_input_response_parser.get_format_instructions()
+
+            eval_prompt = evaluation_prompt(judge_llm_prompt=self.judge_llm_prompt,
+                                            question=question,
+                                            answer_description=answer_description,
+                                            generated_answer=generated_answer,
+                                            format_instructions=format_instructions,
+                                            default_scoring=self.default_scoring)
+
+            messages = [
+                SystemMessage(content="You must respond only in JSON format."), HumanMessage(content=eval_prompt)
+            ]
+
+            response = await self.llm.ainvoke(messages)
+
+            # Initialize default values to handle service errors
+            coverage_score = 0.0
+            correctness_score = 0.0
+            relevance_score = 0.0
+            reasoning = "Error in evaluator from parsing judge LLM response."
+
+            try:
+                parsed_response = llm_input_response_parser.parse(response.content)
+                if self.default_scoring:
+                    try:
+                        coverage_score = parsed_response["coverage_score"]
+                        correctness_score = parsed_response["correctness_score"]
+                        relevance_score = parsed_response["relevance_score"]
+                        reasoning = parsed_response["reasoning"]
+                    except KeyError as e:
+                        logger.error("Missing required keys in default scoring response: %s",
+                                     ", ".join(str(arg) for arg in e.args))
+                        reasoning = f"Error in evaluator from parsing judge LLM response. Missing required key(s): {', '.join(str(arg) for arg in e.args)}"
+
+                    coverage_weight = self.default_score_weights.get("coverage", 1 / 3)
+                    correctness_weight = self.default_score_weights.get("correctness", 1 / 3)
+                    relevance_weight = self.default_score_weights.get("relevance", 1 / 3)
+
+                    # Calculate score
+                    total_weight = coverage_weight + correctness_weight + relevance_weight
+                    coverage_weight = coverage_weight / total_weight
+                    correctness_weight = correctness_weight / total_weight
+                    relevance_weight = relevance_weight / total_weight
+
+                    if round(coverage_weight + correctness_weight + relevance_weight, 2) != 1:
+                        logger.warning("The sum of the default score weights is not 1. The weights will be normalized.")
+                        coverage_weight = coverage_weight / (coverage_weight + correctness_weight + relevance_weight)
+                        correctness_weight = correctness_weight / (coverage_weight + correctness_weight +
+                                                                   relevance_weight)
+                        relevance_weight = relevance_weight / (coverage_weight + correctness_weight + relevance_weight)
+
+                    score = (coverage_weight * coverage_score + correctness_weight * correctness_score +
+                             relevance_weight * relevance_score)
+
+                else:
+                    try:
+                        score = parsed_response["score"]
+                        reasoning = parsed_response["reasoning"]
+                    except KeyError as e:
+                        logger.error("Missing required keys in custom scoring response: %s",
+                                     ", ".join(str(arg) for arg in e.args))
+                        reasoning = f"Error in evaluator from parsing judge LLM response. Missing required key(s): {', '.join(str(arg) for arg in e.args)}"
+                        raise
+            except (KeyError, ValueError) as e:
+                logger.error("Error parsing judge LLM response: %s", e)
+                score = 0.0
+                reasoning = "Error in evaluator from parsing judge LLM response."
+
+            if self.default_scoring:
+                reasoning = {
+                    "question": question,
+                    "answer_description": answer_description,
+                    "generated_answer": generated_answer,
+                    "score_breakdown": {
+                        "coverage_score": coverage_score,
+                        "correctness_score": correctness_score,
+                        "relevance_score": relevance_score,
+                    },
+                    "reasoning": reasoning,
+                }
+            else:
+                reasoning = {
+                    "question": question,
+                    "answer_description": answer_description,
+                    "generated_answer": generated_answer,
+                    "reasoning": reasoning
+                }
+
+            return score, reasoning
+
+        async def wrapped_process(item: EvalInputItem) -> tuple[float, dict]:
+            """
+            Process an item asynchronously and update the progress bar.
+            Use the semaphore to limit the number of concurrent items.
+            """
+            async with self.semaphore:
+                result = await process_item(item)
+                # Update the progress bar
+                pbar.update(1)
+                return result
+
+        try:
+            # Claim a tqdm position to display the progress bar
+            tqdm_position = TqdmPositionRegistry.claim()
+            # Create a progress bar
+            pbar = tqdm(total=len(eval_input.eval_input_items), desc="Evaluating RAG", position=tqdm_position)
+            # Process items concurrently with a limit on concurrency
+            results = await asyncio.gather(*[wrapped_process(item) for item in eval_input.eval_input_items])
+        finally:
+            pbar.close()
+            TqdmPositionRegistry.release(tqdm_position)
+
+        # Extract scores and reasonings
+        sample_scores, sample_reasonings = zip(*results) if results else ([], [])
+
+        # Compute average score
+        avg_score = round(sum(sample_scores) / len(sample_scores), 2) if sample_scores else 0.0
+
+        # Construct EvalOutputItems
+        eval_output_items = [
+            EvalOutputItem(id=item.id, score=score, reasoning=reasoning)
+            for item, score, reasoning in zip(eval_input.eval_input_items, sample_scores, sample_reasonings)
+        ]
+
+        return EvalOutput(average_score=avg_score, eval_output_items=eval_output_items)

aiq/eval/tunable_rag_evaluator/register.py

@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import Field
+
+from aiq.builder.builder import EvalBuilder
+from aiq.builder.evaluator import EvaluatorInfo
+from aiq.builder.framework_enum import LLMFrameworkEnum
+from aiq.cli.register_workflow import register_evaluator
+from aiq.data_models.component_ref import LLMRef
+from aiq.data_models.evaluator import EvaluatorBaseConfig
+
+
+class TunableRagEvaluatorConfig(EvaluatorBaseConfig, name="tunable_rag_evaluator"):
+    '''Configuration for tunable RAG evaluator'''
+    llm_name: LLMRef = Field(description="Name of the judge LLM")
+    judge_llm_prompt: str = Field(description="LLM prompt for the judge LLM")
+    default_scoring: bool = Field(description="Whether to use default scoring", default=False)
+    default_score_weights: dict = Field(
+        default={
+            "coverage": 0.5, "correctness": 0.3, "relevance": 0.2
+        },
+        description="Weights for the different scoring components when using default scoring")
+
+
+@register_evaluator(config_type=TunableRagEvaluatorConfig)
+async def register_tunable_rag_evaluator(config: TunableRagEvaluatorConfig, builder: EvalBuilder):
+    '''Register tunable RAG evaluator'''
+    from .evaluate import TunableRagEvaluator
+
+    llm = await builder.get_llm(config.llm_name, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+    evaluator = TunableRagEvaluator(llm,
+                                    config.judge_llm_prompt,
+                                    builder.get_max_concurrency(),
+                                    config.default_scoring,
+                                    config.default_score_weights)
+
+    yield EvaluatorInfo(config=config, evaluate_fn=evaluator.evaluate, description="Tunable RAG Evaluator")

aiq/front_ends/console/console_front_end_config.py

@@ -22,7 +22,7 @@ from aiq.data_models.front_end import FrontEndBaseConfig
 
 class ConsoleFrontEndConfig(FrontEndBaseConfig, name="console"):
     """
-    A front end that allows an AgentIQ workflow to be run from the console.
+    A front end that allows an AIQ Toolkit workflow to be run from the console.
     """
 
     input_query: list[str] | None = Field(default=None,

aiq/front_ends/fastapi/fastapi_front_end_config.py

@@ -57,7 +57,7 @@ class AIQEvaluateStatusResponse(BaseModel):
 
 class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
     """
-    A FastAPI based front end that allows an AgentIQ workflow to be served as a microservice.
+    A FastAPI based front end that allows an AIQ Toolkit workflow to be served as a microservice.
     """
 
     class EndpointBase(BaseModel):
@@ -119,7 +119,7 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
         path="/generate",
         websocket_path="/websocket",
         openai_api_path="/chat",
-        description="Executes the default AgentIQ workflow from the loaded configuration ",
+        description="Executes the default AIQ Toolkit workflow from the loaded configuration ",
     )
 
     evaluate: typing.Annotated[EndpointBase, Field(description="Endpoint for evaluating workflows.")] = EndpointBase(
@@ -131,7 +131,7 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
     endpoints: list[Endpoint] = Field(
         default_factory=list,
         description=(
-            "Additional endpoints to add to the FastAPI app which run functions within the AgentIQ configuration. "
+            "Additional endpoints to add to the FastAPI app which run functions within the AIQ Toolkit configuration. "
             "Each endpoint must have a unique path."))
 
     cors: CrossOriginResourceSharing = Field(
@@ -144,7 +144,7 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
     )
     runner_class: str | None = Field(
         default=None,
-        description=("The AgentIQ runner class to use when launching the FastAPI app from multiple processes. "
-                     "Each runner is responsible for loading and running the AgentIQ workflow. "
+        description=("The AIQ Toolkit runner class to use when launching the FastAPI app from multiple processes. "
+                     "Each runner is responsible for loading and running the AIQ Toolkit workflow. "
                      "Note: This is different from the worker class used by Gunicorn."),
     )

aiq/front_ends/fastapi/fastapi_front_end_plugin_worker.py

@@ -49,7 +49,7 @@ from aiq.front_ends.fastapi.job_store import JobInfo
 from aiq.front_ends.fastapi.job_store import JobStore
 from aiq.front_ends.fastapi.response_helpers import generate_single_response
 from aiq.front_ends.fastapi.response_helpers import generate_streaming_response_as_str
-from aiq.front_ends.fastapi.response_helpers import generate_streaming_response_raw_as_str
+from aiq.front_ends.fastapi.response_helpers import generate_streaming_response_full_as_str
 from aiq.front_ends.fastapi.step_adaptor import StepAdaptor
 from aiq.front_ends.fastapi.websocket import AIQWebSocket
 from aiq.runtime.session import AIQSessionManager
@@ -82,7 +82,7 @@ class FastApiFrontEndPluginWorkerBase(ABC):
         @asynccontextmanager
         async def lifespan(starting_app: FastAPI):
 
-            logger.debug("Starting AgentIQ server from process %s", os.getpid())
+            logger.debug("Starting AIQ Toolkit server from process %s", os.getpid())
 
             async with WorkflowBuilder.from_config(self.config) as builder:
 
@@ -96,7 +96,7 @@ class FastApiFrontEndPluginWorkerBase(ABC):
                     logger.info("Cancelling cleanup task")
                     cleanup_task.cancel()
 
-            logger.debug("Closing AgentIQ server from process %s", os.getpid())
+            logger.debug("Closing AIQ Toolkit server from process %s", os.getpid())
 
         aiq_app = FastAPI(lifespan=lifespan)
 
@@ -396,14 +396,16 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
 
         def get_streaming_raw_endpoint(streaming: bool, result_type: type | None, output_type: type | None):
 
-            async def get_stream():
+            async def get_stream(filter_steps: str | None = None):
 
                 return StreamingResponse(headers={"Content-Type": "text/event-stream; charset=utf-8"},
-                                         content=generate_streaming_response_raw_as_str(None,
-                                                                                        session_manager=session_manager,
-                                                                                        streaming=streaming,
-                                                                                        result_type=result_type,
-                                                                                        output_type=output_type))
+                                         content=generate_streaming_response_full_as_str(
+                                             None,
+                                             session_manager=session_manager,
+                                             streaming=streaming,
+                                             result_type=result_type,
+                                             output_type=output_type,
+                                             filter_steps=filter_steps))
 
             return get_stream
 
@@ -443,14 +445,16 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
             Stream raw intermediate steps without any step adaptor translations.
             """
 
-            async def post_stream(payload: request_type):
+            async def post_stream(payload: request_type, filter_steps: str | None = None):
 
                 return StreamingResponse(headers={"Content-Type": "text/event-stream; charset=utf-8"},
-                                         content=generate_streaming_response_raw_as_str(payload,
-                                                                                        session_manager=session_manager,
-                                                                                        streaming=streaming,
-                                                                                        result_type=result_type,
-                                                                                        output_type=output_type))
+                                         content=generate_streaming_response_full_as_str(
+                                             payload,
+                                             session_manager=session_manager,
+                                             streaming=streaming,
+                                             result_type=result_type,
+                                             output_type=output_type,
+                                             filter_steps=filter_steps))
 
             return post_stream
 
@@ -478,11 +482,14 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                 )
 
                 app.add_api_route(
-                    path=f"{endpoint.path}/stream/full",
+                    path=f"{endpoint.path}/full",
                     endpoint=get_streaming_raw_endpoint(streaming=True,
                                                         result_type=GenerateStreamResponseType,
                                                         output_type=GenerateStreamResponseType),
                     methods=[endpoint.method],
+                    description="Stream raw intermediate steps without any step adaptor translations.\n"
+                    "Use filter_steps query parameter to filter steps by type (comma-separated list) or\
+                        set to 'none' to suppress all intermediate steps.",
                 )
 
             elif (endpoint.method == "POST"):
@@ -510,14 +517,16 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                 )
 
                 app.add_api_route(
-                    path=f"{endpoint.path}/stream/full",
+                    path=f"{endpoint.path}/full",
                     endpoint=post_streaming_raw_endpoint(request_type=GenerateBodyType,
                                                          streaming=True,
                                                          result_type=GenerateStreamResponseType,
                                                          output_type=GenerateStreamResponseType),
                     methods=[endpoint.method],
                     response_model=GenerateStreamResponseType,
-                    description="Stream raw intermediate steps without any step adaptor translations",
+                    description="Stream raw intermediate steps without any step adaptor translations.\n"
+                    "Use filter_steps query parameter to filter steps by type (comma-separated list) or \
+                        set to 'none' to suppress all intermediate steps.",
                     responses={500: response_500},
                 )