roboflow-workflows 0.2.2__tar.gz → 0.2.3rc1__tar.gz

{roboflow_workflows-0.2.2/roboflow_workflows.egg-info → roboflow_workflows-0.2.3rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboflow-workflows
-Version: 0.2.2
+Version: 0.2.3rc1
 Summary: Roboflow Workflows execution engine and block library
 License: LICENSE.core (Apache 2.0) applies to all files in this repository
         except for files in or under any directory that contains a superseding
@@ -71,6 +71,17 @@ powers [Roboflow Inference](https://github.com/roboflow/inference).  It can be
 installed independently for use in standalone pipelines or embedded in the
 full Inference server.
 
+## Changelog and versions
+
+[CHANGELOG.md](CHANGELOG.md) records package changes, including an Execution
+engine subsection for compile/run behavior changes. Each release records its
+bundled engine version, starting with package `0.2.2`. The package version
+identifies the distribution; the separate engine version controls workflow and
+block compatibility. Block-only releases can leave the engine version unchanged.
+
+Earlier engine changes and migration examples remain in the
+[historical engine changelog](https://docs.roboflow.com/workflows/developer-guide/developer-guide/execution-engine-changelog).
+
 ## Installation
 
 ```bash

{roboflow_workflows-0.2.2 → roboflow_workflows-0.2.3rc1}/README.md

@@ -7,6 +7,17 @@ powers [Roboflow Inference](https://github.com/roboflow/inference).  It can be
 installed independently for use in standalone pipelines or embedded in the
 full Inference server.
 
+## Changelog and versions
+
+[CHANGELOG.md](CHANGELOG.md) records package changes, including an Execution
+engine subsection for compile/run behavior changes. Each release records its
+bundled engine version, starting with package `0.2.2`. The package version
+identifies the distribution; the separate engine version controls workflow and
+block compatibility. Block-only releases can leave the engine version unchanged.
+
+Earlier engine changes and migration examples remain in the
+[historical engine changelog](https://docs.roboflow.com/workflows/developer-guide/developer-guide/execution-engine-changelog).
+
 ## Installation
 
 ```bash

{roboflow_workflows-0.2.2 → roboflow_workflows-0.2.3rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "roboflow-workflows"
-version = "0.2.2"
+version = "0.2.3rc1"
 description = "Roboflow Workflows execution engine and block library"
 readme = "README.md"
 license = {file = "LICENSE"}

{roboflow_workflows-0.2.2 → roboflow_workflows-0.2.3rc1}/roboflow_workflows/execution_engine/v1/executor/core.py

@@ -11,6 +11,8 @@ import cv2
 import numpy as np
 from roboflow_workflows._compat_names import get_logger
 
+from inference_models.utils.performance import performance_profiler
+
 try:
     from inference_sdk.config import (
         apply_duration_minimum,
@@ -525,21 +527,27 @@ def run_simd_step_in_batch_mode(
             "data_size": len(step_input.indices),
         },
     ):
-        if not step_input.indices:
-            # no inputs - discarded either by conditional exec or by not accepting empty
-            outputs = []
-        else:
-            try:
-                outputs = step_instance.run(**step_input.parameters)
-            except Exception as exc:
-                if INFERENCE_DEBUG_OUTPUT_DIR:
-                    _store_crash_info(
-                        image=execution_data_manager._runtime_parameters["image"][
-                            0
-                        ].numpy_image,
-                        exception=exc,
-                    )
-                raise exc
+        step_started = performance_profiler.start()
+        try:
+            if not step_input.indices:
+                # no inputs - discarded either by conditional exec or by not accepting empty
+                outputs = []
+            else:
+                try:
+                    outputs = step_instance.run(**step_input.parameters)
+                except Exception as exc:
+                    if INFERENCE_DEBUG_OUTPUT_DIR:
+                        _store_crash_info(
+                            image=execution_data_manager._runtime_parameters["image"][
+                                0
+                            ].numpy_image,
+                            exception=exc,
+                        )
+                    raise exc
+        finally:
+            performance_profiler.stop(
+                f"workflow.step_code.{step_selector}", step_started
+            )
     with profiler.profile_execution_phase(
         name="step_output_registration",
         categories=["execution_engine_operation"],
@@ -576,7 +584,13 @@ def run_simd_step_in_non_batch_mode(
                     "step": step_selector,
                 },
             ):
-                result = step_instance.run(**input_definition.parameters)
+                step_started = performance_profiler.start()
+                try:
+                    result = step_instance.run(**input_definition.parameters)
+                finally:
+                    performance_profiler.stop(
+                        f"workflow.step_code.{step_selector}", step_started
+                    )
             results.append(result)
             indices.append(input_definition.index)
     with profiler.profile_execution_phase(
@@ -617,7 +631,13 @@ def run_non_simd_step(
             "step": step_selector,
         },
     ):
-        step_result = step_instance.run(**step_input)
+        step_started = performance_profiler.start()
+        try:
+            step_result = step_instance.run(**step_input)
+        finally:
+            performance_profiler.stop(
+                f"workflow.step_code.{step_selector}", step_started
+            )
     with profiler.profile_execution_phase(
         name="step_output_registration",
         categories=["execution_engine_operation"],

roboflow_workflows-0.2.3rc1/roboflow_workflows/http_contract/describe.py

@@ -0,0 +1,163 @@
+from typing import Dict, List, Optional, Set, Union
+
+from packaging.specifiers import SpecifierSet
+from roboflow_workflows.core_steps.common.query_language.introspection.core import (
+    prepare_operations_descriptions,
+    prepare_operators_descriptions,
+)
+from roboflow_workflows.errors import WorkflowExecutionEngineVersionError
+from roboflow_workflows.execution_engine.core import (
+    retrieve_requested_execution_engine_version,
+)
+from roboflow_workflows.execution_engine.introspection.blocks_loader import (
+    describe_available_blocks,
+)
+from roboflow_workflows.execution_engine.introspection.connections_discovery import (
+    discover_blocks_connections,
+)
+from roboflow_workflows.execution_engine.v1.dynamic_blocks.block_assembler import (
+    compile_dynamic_blocks,
+)
+from roboflow_workflows.execution_engine.v1.dynamic_blocks.entities import (
+    DynamicBlockDefinition,
+)
+from roboflow_workflows.execution_engine.v1.introspection.inputs_discovery import (
+    describe_workflow_inputs,
+)
+from roboflow_workflows.execution_engine.v1.introspection.outputs_discovery import (
+    describe_workflow_outputs,
+)
+from roboflow_workflows.execution_engine.v1.introspection.types_discovery import (
+    discover_kinds_schemas,
+    discover_kinds_typing_hints,
+)
+from roboflow_workflows.http_contract.entities import (
+    DescribeInterfaceResponse,
+    ExternalBlockPropertyPrimitiveDefinition,
+    ExternalWorkflowsBlockSelectorDefinition,
+    UniversalQueryLanguageDescription,
+    WorkflowsBlocksDescription,
+)
+from roboflow_workflows.prototypes.workspace_resolver import (
+    NULL_WORKSPACE_RESOLVER,
+    WorkspaceResolver,
+)
+
+
+def describe_workflows_blocks(
+    dynamic_blocks_definitions: Optional[List[DynamicBlockDefinition]] = None,
+    requested_execution_engine_version: Optional[str] = None,
+    api_key: Optional[str] = None,
+    workspace_resolver: WorkspaceResolver = NULL_WORKSPACE_RESOLVER,
+) -> WorkflowsBlocksDescription:
+    if dynamic_blocks_definitions is None:
+        dynamic_blocks_definitions = []
+    dynamic_blocks = compile_dynamic_blocks(
+        dynamic_blocks_definitions=dynamic_blocks_definitions,
+        api_key=api_key,
+        workspace_resolver=workspace_resolver,
+    )
+    blocks_description = describe_available_blocks(
+        dynamic_blocks=dynamic_blocks,
+        execution_engine_version=requested_execution_engine_version,
+    )
+    blocks_connections = discover_blocks_connections(
+        blocks_description=blocks_description,
+    )
+    kinds_connections = {
+        kind_name: [
+            ExternalWorkflowsBlockSelectorDefinition(
+                manifest_type_identifier=c.manifest_type_identifier,
+                property_name=c.property_name,
+                property_description=c.property_description,
+                compatible_element=c.compatible_element,
+                is_list_element=c.is_list_element,
+                is_dict_element=c.is_dict_element,
+            )
+            for c in connections
+        ]
+        for kind_name, connections in blocks_connections.kinds_connections.items()
+    }
+    primitives_connections = [
+        ExternalBlockPropertyPrimitiveDefinition(
+            manifest_type_identifier=primitives_connection.manifest_type_identifier,
+            property_name=primitives_connection.property_name,
+            property_description=primitives_connection.property_description,
+            type_annotation=primitives_connection.type_annotation,
+        )
+        for primitives_connection in blocks_connections.primitives_connections
+    ]
+    uql_operations_descriptions = prepare_operations_descriptions()
+    uql_operators_descriptions = prepare_operators_descriptions()
+    universal_query_language_description = (
+        UniversalQueryLanguageDescription.from_internal_entities(
+            operations_descriptions=uql_operations_descriptions,
+            operators_descriptions=uql_operators_descriptions,
+        )
+    )
+    return WorkflowsBlocksDescription(
+        blocks=blocks_description.blocks,
+        declared_kinds=blocks_description.declared_kinds,
+        kinds_connections=kinds_connections,
+        primitives_connections=primitives_connections,
+        universal_query_language_description=universal_query_language_description,
+        dynamic_block_definition_schema=DynamicBlockDefinition.schema(),
+    )
+
+
+def describe_workflow_interface(
+    definition: dict,
+) -> DescribeInterfaceResponse:
+    requested_execution_engine_version = retrieve_requested_execution_engine_version(
+        workflow_definition=definition
+    )
+    if not SpecifierSet(f">=1.0.0,<2.0.0").contains(requested_execution_engine_version):
+        raise WorkflowExecutionEngineVersionError(
+            public_message="Describing workflow outputs is only supported for Execution Engine v1.",
+            context="describing_workflow_outputs",
+        )
+    inputs = describe_workflow_inputs(definition=definition)
+    outputs = describe_workflow_outputs(definition=definition)
+    unique_kinds = get_unique_kinds(inputs=inputs, outputs=outputs)
+    typing_hints = discover_kinds_typing_hints(kinds_names=unique_kinds)
+    kinds_schemas = discover_kinds_schemas(kinds_names=unique_kinds)
+    return DescribeInterfaceResponse(
+        inputs=inputs,
+        outputs=outputs,
+        typing_hints=typing_hints,
+        kinds_schemas=kinds_schemas,
+    )
+
+
+def get_unique_kinds(
+    inputs: Dict[str, List[str]],
+    outputs: Dict[str, Union[List[str], Dict[str, List[str]]]],
+) -> Set[str]:
+    all_kinds = set()
+    for input_element_kinds in inputs.values():
+        all_kinds.update(input_element_kinds)
+    for output_definition in outputs.values():
+        if isinstance(output_definition, list):
+            all_kinds.update(output_definition)
+        if isinstance(output_definition, dict):
+            for output_field_kinds in output_definition.values():
+                all_kinds.update(output_field_kinds)
+    return all_kinds
+
+
+def filter_out_unwanted_workflow_outputs(
+    workflow_results: List[dict],
+    excluded_fields: Optional[List[str]],
+) -> List[dict]:
+    if not excluded_fields:
+        return workflow_results
+    excluded_fields = set(excluded_fields)
+    filtered_results = []
+    for result_element in workflow_results:
+        filtered_result = {}
+        for key, value in result_element.items():
+            if key in excluded_fields:
+                continue
+            filtered_result[key] = value
+        filtered_results.append(filtered_result)
+    return filtered_results

roboflow_workflows-0.2.3rc1/roboflow_workflows/http_contract/entities.py

@@ -0,0 +1,344 @@
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+from roboflow_workflows.core_steps.common.query_language.entities.introspection import (
+    OperationDescription,
+    OperatorDescription,
+)
+from roboflow_workflows.errors import WorkflowBlockError
+from roboflow_workflows.execution_engine.entities.types import Kind
+from roboflow_workflows.execution_engine.introspection.entities import BlockDescription
+from roboflow_workflows.execution_engine.v1.dynamic_blocks.entities import (
+    DynamicBlockDefinition,
+)
+
+
+class WorkflowInferenceRequest(BaseModel):
+    api_key: Optional[str] = Field(
+        default=None,
+        description="Roboflow API Key that will be passed to the model during initialization for artifact retrieval",
+    )
+    inputs: Dict[str, Any] = Field(
+        description="Dictionary that contains each parameter defined as an input for chosen workflow"
+    )
+    excluded_fields: Optional[List[str]] = Field(
+        default=None,
+        description="List of field that shall be excluded from the response (among those defined in workflow specification)",
+    )
+    enable_profiling: bool = Field(
+        default=False,
+        description="Flag to request Workflow run profiling. Enables Workflow profiler only when server settings "
+        "allow profiling traces to be exported to clients. Only applies for Workflows definitions saved "
+        "on Roboflow platform.",
+    )
+    debug: bool = Field(
+        default=False,
+        description="When True, captures stdout/stderr emitted by custom Python blocks executed "
+        "locally and returns them in the response under `python_blocks_output_streams`. Also activates "
+        "the workflow-scoped `debug_traces` variable in custom Python blocks; values appended during "
+        "execution are returned under `python_blocks_debug_traces`. On Modal / OCI sandbox executions "
+        "`debug_traces` is a no-op (entries appended remotely are not collected), but calls are safe "
+        "and will not raise.",
+    )
+    workflow_id: Optional[str] = Field(
+        default=None, description="Optional identifier of workflow"
+    )
+    inner_workflow_dispatch_depth: int = Field(
+        default=0,
+        ge=0,
+        strict=True,
+        description="Number of remote inner-workflow dispatch hops preceding this request.",
+    )
+    disable_sinks: bool = Field(
+        default=False,
+        description="Run the workflow with sink writes and outbound notifications/uploads disabled.",
+    )
+
+
+class PredefinedWorkflowInferenceRequest(WorkflowInferenceRequest):
+    use_cache: bool = Field(
+        default=True,
+        description="Controls usage of cache for workflow definitions. Set this to False when you frequently modify "
+        "definition saved in Roboflow app and want to fetch the newest version for the request.",
+    )
+    workflow_version_id: Optional[str] = Field(
+        default=None,
+        description="Specific version of the workflow to fetch. If not provided, the latest version is used.",
+    )
+
+
+class WorkflowSpecificationInferenceRequest(WorkflowInferenceRequest):
+    specification: dict
+    is_preview: bool = Field(
+        default=False,
+        description="Reserved, used internally by Roboflow to distinguish between preview and non-preview runs",
+    )
+
+
+class DescribeBlocksRequest(BaseModel):
+    api_key: Optional[str] = Field(
+        default=None,
+        description="Roboflow API Key that will be passed to the model during initialization for artifact retrieval",
+    )
+    dynamic_blocks_definitions: List[DynamicBlockDefinition] = Field(
+        default_factory=list, description="Dynamic blocks to be used."
+    )
+    execution_engine_version: Optional[str] = Field(
+        default=None,
+        description="Requested Execution Engine compatibility. If given, result will only "
+        "contain blocks suitable for requested EE version, otherwise - descriptions for "
+        "all available blocks will be delivered.",
+    )
+
+
+class DescribeInterfaceRequest(BaseModel):
+    api_key: Optional[str] = Field(
+        default=None,
+        description="Roboflow API Key that will be passed to the model during initialization for artifact retrieval. "
+        "May alternatively be sent in the `Authorization: Bearer <api_key>` header - the route still requires "
+        "a key through one of the channels.",
+    )
+
+
+class PredefinedWorkflowDescribeInterfaceRequest(DescribeInterfaceRequest):
+    use_cache: bool = Field(
+        default=True,
+        description="Controls usage of cache for workflow definitions. Set this to False when you frequently modify "
+        "definition saved in Roboflow app and want to fetch the newest version for the request. "
+        "Only applies for Workflows definitions saved on Roboflow platform.",
+    )
+    workflow_version_id: Optional[str] = Field(
+        default=None,
+        description="Specific version of the workflow to fetch. If not provided, the latest version is used.",
+    )
+
+
+class WorkflowSpecificationDescribeInterfaceRequest(DescribeInterfaceRequest):
+    specification: dict
+
+
+class WorkflowInferenceResponse(BaseModel):
+    outputs: List[Dict[str, Any]] = Field(
+        description="Dictionary with keys defined in workflow output and serialised values"
+    )
+    profiler_trace: Optional[List[dict]] = Field(
+        description="Profiler events",
+        default=None,
+    )
+    python_blocks_output_streams: Optional[
+        Dict[str, List[Dict[str, Optional[str]]]]
+    ] = Field(
+        default=None,
+        description="When `debug=True` was set on the request, stdout/stderr captured for "
+        "each local custom Python block execution, keyed by step name. Each step maps to "
+        "the list of invocations (in execution order) with `stdout` and `stderr` strings "
+        "(or null if empty). Only populated for local executions.",
+    )
+    python_blocks_debug_traces: Optional[List[Dict[str, Any]]] = Field(
+        default=None,
+        description="When `debug=True` was set on the request, structured debug entries "
+        "appended via the `debug_traces` variable in custom Python blocks, in chronological "
+        "execution order. Each entry has `step` (step name) and `value` (JSON-serialisable "
+        "payload, or string repr for non-serialisable values). When "
+        "`debug_traces.append(..., add_timestamp=True)` was used, the entry also includes "
+        "`timestamp` (ISO-8601) and `timestamp_timezone` (IANA name, default `UTC`). "
+        "Only populated for local executions.",
+    )
+
+
+class WorkflowValidationStatus(BaseModel):
+    status: str = Field(description="Represents validation status")
+
+
+class ExternalWorkflowsBlockSelectorDefinition(BaseModel):
+    manifest_type_identifier: str = Field(description="Identifier of block")
+    property_name: str = Field(description="Name of specific property")
+    property_description: str = Field(description="Description for specific property")
+    compatible_element: str = Field(
+        description="Defines to what type of object (step_output, parameter, etc) reference may be pointing"
+    )
+    is_list_element: bool = Field(
+        description="Boolean flag defining if list of references will be accepted"
+    )
+    is_dict_element: bool = Field(
+        description="Boolean flag defining if dict of references will be accepted"
+    )
+
+
+class ExternalBlockPropertyPrimitiveDefinition(BaseModel):
+    manifest_type_identifier: str = Field(description="Identifier of block")
+    property_name: str = Field(description="Name of specific property")
+    property_description: str = Field(description="Description for specific property")
+    type_annotation: str = Field(
+        description="Pythonic type annotation for property",
+        examples=["Union[str, int]"],
+    )
+
+
+class ExternalOperationDescription(BaseModel):
+    operation_type: str
+    compound: bool
+    input_kind: List[str]
+    output_kind: List[str]
+    nested_operation_input_kind: Optional[List[str]] = None
+    nested_operation_output_kind: Optional[List[str]] = None
+    description: Optional[str] = None
+
+    property_name_options: Optional[List[str]] = Field(
+        default=None,
+        description=("List of possible property names. \
+            Optional parameter for operations extracting property values from data. "),
+        examples=[
+            "size",
+            "height",
+            "width",
+            "aspect_ratio",
+        ],
+    )
+
+    @classmethod
+    def from_internal_entity(
+        cls, operation_description: OperationDescription
+    ) -> "ExternalOperationDescription":
+        nested_operation_input_kind, nested_operation_output_kind = None, None
+        if operation_description.nested_operation_input_kind:
+            nested_operation_input_kind = [
+                k.name for k in operation_description.nested_operation_input_kind
+            ]
+        if operation_description.nested_operation_output_kind:
+            nested_operation_output_kind = [
+                k.name for k in operation_description.nested_operation_output_kind
+            ]
+        return cls(
+            operation_type=operation_description.operation_type,
+            compound=operation_description.compound,
+            input_kind=[k.name for k in operation_description.input_kind],
+            output_kind=[k.name for k in operation_description.output_kind],
+            nested_operation_input_kind=nested_operation_input_kind,
+            nested_operation_output_kind=nested_operation_output_kind,
+            description=operation_description.description,
+            property_name_options=operation_description.property_name_options,
+        )
+
+
+class ExternalOperatorDescription(BaseModel):
+    operator_type: str
+    operands_number: int
+    operands_kinds: List[List[str]]
+    description: Optional[str] = None
+
+    @classmethod
+    def from_internal_entity(
+        cls, operator_description: OperatorDescription
+    ) -> "ExternalOperatorDescription":
+        operands_kinds = [
+            [k.name for k in kind] for kind in operator_description.operands_kinds
+        ]
+        return cls(
+            operator_type=operator_description.operator_type,
+            operands_number=operator_description.operands_number,
+            operands_kinds=operands_kinds,
+            description=operator_description.description,
+        )
+
+
+class UniversalQueryLanguageDescription(BaseModel):
+    operations_description: List[ExternalOperationDescription]
+    operators_descriptions: List[ExternalOperatorDescription]
+
+    @classmethod
+    def from_internal_entities(
+        cls,
+        operations_descriptions: List[OperationDescription],
+        operators_descriptions: List[OperatorDescription],
+    ) -> "UniversalQueryLanguageDescription":
+        operations_descriptions = [
+            ExternalOperationDescription.from_internal_entity(
+                operation_description=operation_description
+            )
+            for operation_description in operations_descriptions
+        ]
+        operators_descriptions = [
+            ExternalOperatorDescription.from_internal_entity(
+                operator_description=operator_description
+            )
+            for operator_description in operators_descriptions
+        ]
+        return cls(
+            operations_description=operations_descriptions,
+            operators_descriptions=operators_descriptions,
+        )
+
+
+class WorkflowsBlocksDescription(BaseModel):
+    blocks: List[BlockDescription] = Field(
+        description="List of loaded blocks descriptions"
+    )
+    declared_kinds: List[Kind] = Field(description="List of kinds defined for blocks")
+    kinds_connections: Dict[str, List[ExternalWorkflowsBlockSelectorDefinition]] = (
+        Field(
+            description="Mapping from kind name into list of blocks properties accepting references of that kind"
+        )
+    )
+    primitives_connections: List[ExternalBlockPropertyPrimitiveDefinition] = Field(
+        description="List defining all properties for all blocks that can be filled "
+        "with primitive values in workflow definition."
+    )
+    universal_query_language_description: UniversalQueryLanguageDescription = Field(
+        description="Definitions of Universal Query Language operations and operators"
+    )
+    dynamic_block_definition_schema: dict = Field(
+        description="Schema for dynamic block definition"
+    )
+
+
+class ExecutionEngineVersions(BaseModel):
+    versions: List[str]
+
+
+class WorkflowsBlocksSchemaDescription(BaseModel):
+    model_config = ConfigDict(protected_namespaces=())
+    schema: dict = Field(description="Schema for validating block definitions")
+
+
+class DescribeInterfaceResponse(BaseModel):
+    inputs: Dict[str, List[str]] = Field(
+        description="Dictionary mapping Workflow inputs to their kinds"
+    )
+    outputs: Dict[str, Union[List[str], Dict[str, List[str]]]] = Field(
+        description="Dictionary mapping Workflow outputs to their kinds"
+    )
+    typing_hints: Dict[str, str] = Field(
+        description="Dictionary mapping name of the kind with Python typing hint for underlying serialised object",
+    )
+    kinds_schemas: Dict[str, Union[dict, List[dict]]] = Field(
+        description="Dictionary mapping name of the kind with OpenAPI 3.0 definitions of underlying objects. "
+        "If list is given, entity should be treated as union of types."
+    )
+
+
+class WorkflowErrorResponse(BaseModel):
+    message: str
+    error_type: str
+    context: str
+    inner_error_type: Optional[str] = None
+    inner_error_message: Optional[str] = None
+    blocks_errors: Optional[List[WorkflowBlockError]] = None
+    python_blocks_output_streams: Optional[
+        Dict[str, List[Dict[str, Optional[str]]]]
+    ] = Field(
+        default=None,
+        description="When `debug=True` was set on the request, stdout/stderr captured for "
+        "each local custom Python block execution that completed before (or caused) the "
+        "failure, keyed by step name. Same format as on `WorkflowInferenceResponse`. "
+        "Best-effort: logs from steps running in parallel with the failing step may be "
+        "missing if those steps had not finished recording when the failure propagated.",
+    )
+    python_blocks_debug_traces: Optional[List[Dict[str, Any]]] = Field(
+        default=None,
+        description="When `debug=True` was set on the request, structured debug entries "
+        "appended via the `debug_traces` variable before (or at) the failure. Same format as on "
+        "`WorkflowInferenceResponse`. Best-effort: entries from steps running in parallel with "
+        "the failing step may be missing if those steps had not finished recording when the "
+        "failure propagated.",
+    )