Skip to content
sgp
API Reference
Evaluation Dashboards

Widgets

Add Widget to Dashboard
evaluation_dashboards.widgets.create(strdashboard_id, WidgetCreateParams**kwargs) -> EvaluationDashboardWidgetWithResult
POST/v5/evaluation-dashboards/{dashboard_id}/widgets
Update Dashboard Widget
evaluation_dashboards.widgets.update(strwidget_id, WidgetUpdateParams**kwargs) -> EvaluationDashboardWidgetWithResult
PATCH/v5/evaluation-dashboards/{dashboard_id}/widgets/{widget_id}
Remove Widget from Dashboard
evaluation_dashboards.widgets.remove(strwidget_id, WidgetRemoveParams**kwargs)
DELETE/v5/evaluation-dashboards/{dashboard_id}/widgets/{widget_id}
ModelsExpand Collapse
class EvaluationDashboardWidget: …
id: str

Unique identifier of the widget

account_id: str

Account that owns this widget

created_at: datetime

When the widget was created

formatdate-time
title: str

Widget title

type: EvaluationWidgetTypeEnum

Widget type

One of the following:
"bar"
"histogram"
"donut"
"scatter"
"metric"
"table"
"markdown"
"heading"
"timeseries"
archived_at: Optional[datetime]

When the widget was archived (soft-deleted)

formatdate-time
config: Optional[Dict[str, object]]

Chart-specific display configuration

object: Optional[Literal["evaluation_dashboard_widget"]]
query: Optional[Query]

Structured query AST for metric computation (SeriesQuery or MetricQuery)

One of the following:
class SeriesQuery: …

Query that returns a series of records (used for table/bar/histogram/donut/scatter widgets).

Used for widget types: table, bar, histogram, donut, scatter. Returns: {“type”: “series”, “data”: […]}

Example SQL equivalent: SELECT category, AVG(score) as avg_score, COUNT(*) as count FROM evaluation_items WHERE score > 0.5 AND category = ‘test’ GROUP BY category ORDER BY avg_score DESC LIMIT 100

select: List[SelectItem]
expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

filter: Optional[Filter]

Filter conditions (WHERE clause)

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
group_by: Optional[List[str]]

Columns to group by

latest_only: Optional[bool]

When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

limit: Optional[int]

Max rows to return

minimum1
order_by: Optional[List[OrderBy]]

Sort order

column: str

Column name to sort by

direction: Optional[Literal["ASC", "DESC"]]

Sort direction

One of the following:
"ASC"
"DESC"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

class MetricQuery: …

Query that returns a single metric value (used for metric widgets).

Used for widget type: metric. Enforces exactly 1 aggregation in select. Returns: {“type”: “metric”, “data”: …}

Example SQL equivalent: SELECT AVG(score) as average_score FROM evaluation_items

select: List[SelectItem]
expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

filter: Optional[Filter]

Filter conditions (WHERE clause)

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
latest_only: Optional[bool]

When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

class EvaluationDashboardWidgetResult: …
id: str

Unique identifier of the widget result

account_id: str

Account that owns this widget result

computation_status: Literal["pending", "completed", "failed"]

Status of the computation

One of the following:
"pending"
"completed"
"failed"
created_at: datetime

When the widget result was created

formatdate-time
widget_id: str

Unique identifier of the widget

computation_job_id: Optional[str]

Temporal workflow ID or job ID for async computation tracking

computed_at: Optional[datetime]

Timestamp when computation completed successfully

formatdate-time
computed_result: Optional[Dict[str, object]]

Cached computation results

error_message: Optional[str]

Error message if computation failed

evaluation_group_id: Optional[str]

FK to evaluation_groups. Null if result is for a single evaluation.

evaluation_id: Optional[str]

FK to evaluations. Null if result is for an evaluation group.

object: Optional[Literal["evaluation_dashboard_widget_result"]]
widget: Optional[EvaluationDashboardWidget]

Widget that this result is for

id: str

Unique identifier of the widget

account_id: str

Account that owns this widget

created_at: datetime

When the widget was created

formatdate-time
title: str

Widget title

type: EvaluationWidgetTypeEnum

Widget type

One of the following:
"bar"
"histogram"
"donut"
"scatter"
"metric"
"table"
"markdown"
"heading"
"timeseries"
archived_at: Optional[datetime]

When the widget was archived (soft-deleted)

formatdate-time
config: Optional[Dict[str, object]]

Chart-specific display configuration

object: Optional[Literal["evaluation_dashboard_widget"]]
query: Optional[Query]

Structured query AST for metric computation (SeriesQuery or MetricQuery)

One of the following:
class SeriesQuery: …

Query that returns a series of records (used for table/bar/histogram/donut/scatter widgets).

Used for widget types: table, bar, histogram, donut, scatter. Returns: {“type”: “series”, “data”: […]}

Example SQL equivalent: SELECT category, AVG(score) as avg_score, COUNT(*) as count FROM evaluation_items WHERE score > 0.5 AND category = ‘test’ GROUP BY category ORDER BY avg_score DESC LIMIT 100

select: List[SelectItem]
expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

filter: Optional[Filter]

Filter conditions (WHERE clause)

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
group_by: Optional[List[str]]

Columns to group by

latest_only: Optional[bool]

When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

limit: Optional[int]

Max rows to return

minimum1
order_by: Optional[List[OrderBy]]

Sort order

column: str

Column name to sort by

direction: Optional[Literal["ASC", "DESC"]]

Sort direction

One of the following:
"ASC"
"DESC"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

class MetricQuery: …

Query that returns a single metric value (used for metric widgets).

Used for widget type: metric. Enforces exactly 1 aggregation in select. Returns: {“type”: “metric”, “data”: …}

Example SQL equivalent: SELECT AVG(score) as average_score FROM evaluation_items

select: List[SelectItem]
expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

filter: Optional[Filter]

Filter conditions (WHERE clause)

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
latest_only: Optional[bool]

When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

class EvaluationDashboardWidgetResultResponse: …

Computed result for a widget - used in widget creation response

id: str

Unique identifier of the widget result

computation_status: str

Status: pending, completed, or failed

widget_id: str

Widget ID this result belongs to

computed_at: Optional[datetime]

When computation completed

formatdate-time
computed_result: Optional[Dict[str, object]]

Computed result data. Metric: {type: ‘metric’, data: 42}, Series: {type: ‘series’, data: [{x: ‘A’, y: 10}, …]}

error_message: Optional[str]

Error message if computation failed

class EvaluationDashboardWidgetWithResult: …

Response model for widget creation - includes widget and computed result

id: str

Unique identifier of the widget

account_id: str

Account that owns this widget

created_at: datetime

When the widget was created

formatdate-time
title: str

Widget title

type: EvaluationWidgetTypeEnum

Widget type

One of the following:
"bar"
"histogram"
"donut"
"scatter"
"metric"
"table"
"markdown"
"heading"
"timeseries"
config: Optional[Dict[str, object]]

Display configuration

object: Optional[Literal["evaluation_widget"]]
query: Optional[Query]

Structured query AST for computation (SeriesQuery or MetricQuery)

One of the following:
class SeriesQuery: …

Query that returns a series of records (used for table/bar/histogram/donut/scatter widgets).

Used for widget types: table, bar, histogram, donut, scatter. Returns: {“type”: “series”, “data”: […]}

Example SQL equivalent: SELECT category, AVG(score) as avg_score, COUNT(*) as count FROM evaluation_items WHERE score > 0.5 AND category = ‘test’ GROUP BY category ORDER BY avg_score DESC LIMIT 100

select: List[SelectItem]
expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

filter: Optional[Filter]

Filter conditions (WHERE clause)

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
group_by: Optional[List[str]]

Columns to group by

latest_only: Optional[bool]

When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

limit: Optional[int]

Max rows to return

minimum1
order_by: Optional[List[OrderBy]]

Sort order

column: str

Column name to sort by

direction: Optional[Literal["ASC", "DESC"]]

Sort direction

One of the following:
"ASC"
"DESC"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

class MetricQuery: …

Query that returns a single metric value (used for metric widgets).

Used for widget type: metric. Enforces exactly 1 aggregation in select. Returns: {“type”: “metric”, “data”: …}

Example SQL equivalent: SELECT AVG(score) as average_score FROM evaluation_items

select: List[SelectItem]
expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

filter: Optional[Filter]

Filter conditions (WHERE clause)

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
latest_only: Optional[bool]

When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

result: Optional[EvaluationDashboardWidgetResultResponse]

Computed result for this widget

id: str

Unique identifier of the widget result

computation_status: str

Status: pending, completed, or failed

widget_id: str

Widget ID this result belongs to

computed_at: Optional[datetime]

When computation completed

formatdate-time
computed_result: Optional[Dict[str, object]]

Computed result data. Metric: {type: ‘metric’, data: 42}, Series: {type: ‘series’, data: [{x: ‘A’, y: 10}, …]}

error_message: Optional[str]

Error message if computation failed

Literal["bar", "histogram", "donut", 6 more]

Widget types for dashboard visualizations

One of the following:
"bar"
"histogram"
"donut"
"scatter"
"metric"
"table"
"markdown"
"heading"
"timeseries"
class Filter: …

Filter clause with conditions connected by logical operators.

Conditions are evaluated left-to-right without precedence (no nesting/parentheses). Example: condition1 AND condition2 OR condition3 evaluates as ((condition1 AND condition2) OR condition3)

Example: { “conditions”: [ {“column”: “score”, “operator”: ”>”, “value”: 0.5}, {“column”: “category”, “operator”: ”=”, “value”: “test”} ], “logicalOperators”: [“AND”] }

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
class MetricQuery: …

Query that returns a single metric value (used for metric widgets).

Used for widget type: metric. Enforces exactly 1 aggregation in select. Returns: {“type”: “metric”, “data”: …}

Example SQL equivalent: SELECT AVG(score) as average_score FROM evaluation_items

select: List[SelectItem]
expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

filter: Optional[Filter]

Filter conditions (WHERE clause)

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
latest_only: Optional[bool]

When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

class SelectItem: …

Column in SELECT clause

expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

class SeriesQuery: …

Query that returns a series of records (used for table/bar/histogram/donut/scatter widgets).

Used for widget types: table, bar, histogram, donut, scatter. Returns: {“type”: “series”, “data”: […]}

Example SQL equivalent: SELECT category, AVG(score) as avg_score, COUNT(*) as count FROM evaluation_items WHERE score > 0.5 AND category = ‘test’ GROUP BY category ORDER BY avg_score DESC LIMIT 100

select: List[SelectItem]
expression: Expression

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

One of the following:
class ExpressionColumn: …

Reference to a column from evaluation_items.data

Example: {“type”: “COLUMN”, “column”: “category”}

column: str

Column name from evaluation_items.data

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["COLUMN"]]
class ExpressionAggregation: …

Aggregation function to apply

Examples: {“type”: “AGGREGATION”, “function”: “AVG”, “column”: “score”} {“type”: “AGGREGATION”, “function”: “COUNT”, “column”: ”*”} {“type”: “AGGREGATION”, “function”: “PERCENTILE”, “column”: “score”, “params”: {“percentile”: 95}}

column: str

Column to aggregate, or '' for COUNT()

function: Literal["COUNT", "SUM", "AVG", 7 more]

Supported aggregation functions

One of the following:
"COUNT"
"SUM"
"AVG"
"MIN"
"MAX"
"STDDEV"
"VARIANCE"
"PERCENTILE"
"COUNT_DISTINCT"
"PERCENTAGE"
evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

params: Optional[Dict[str, object]]

Function parameters (e.g., {‘percentile’: 95} for PERCENTILE, {‘percentage_filters’: Filter} for PERCENTAGE)

source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

type: Optional[Literal["AGGREGATION"]]
alias: Optional[str]

Optional alias for the selected item

evaluation_ids: Optional[List[str]]

Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

filter: Optional[Filter]

Filter conditions (WHERE clause)

conditions: List[Condition]
column: str

Column name to filter on

operator: Literal["=", "!=", ">", 9 more]

Comparison operator

One of the following:
"="
"!="
">"
"<"
">="
"<="
"IN"
"NOT IN"
"LIKE"
"NOT LIKE"
"IS NULL"
"IS NOT NULL"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’

value: Optional[Union[str, float, bool, 2 more]]

Value to compare against. Not required for IS NULL / IS NOT NULL operators.

One of the following:
str
float
bool
List[object]
logical_operators: Optional[List[Literal["AND", "OR"]]]

Logical operators connecting conditions. Length must be len(conditions) - 1

One of the following:
"AND"
"OR"
group_by: Optional[List[str]]

Columns to group by

latest_only: Optional[bool]

When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

limit: Optional[int]

Max rows to return

minimum1
order_by: Optional[List[OrderBy]]

Sort order

column: str

Column name to sort by

direction: Optional[Literal["ASC", "DESC"]]

Sort direction

One of the following:
"ASC"
"DESC"
source: Optional[str]

Column source: ‘data’ or ‘task_result_cache’