Dashboards

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.dashboards.list(page=1, page_size=25)

result = await client.dashboards.a_list(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.dashboards.list({ page: 1, pageSize: 25 });

from confident_ai import ConfidentAI
from confident_ai.common import CreateWidgetRequest
from confident_ai.common import FilterSet
from confident_ai.common import WidgetLayout
from confident_ai.common import WidgetLineConfig
from confident_ai.common import WidgetTopK

client = ConfidentAI()

result = client.dashboards.create(
    name="Production overview",
    description="Traffic and latency across production.",
    private=False,
    widgets=[
        CreateWidgetRequest(
            name="Trace volume",
            description="Traces served per day across production.",
            type="LINE",
            unit="COUNT",
            mode="TIME_SERIES",
            bucket_mode="SERIES",
            dimension="model",
            top_k=WidgetTopK(
                limit=10,
                order_by="p90_latency",
                direction="desc"
            ),
            start_time="2025-01-01T00:00:00+00:00",
            end_time="2025-01-31T23:59:59.999000+00:00",
            layout=WidgetLayout(
                x=0,
                y=0,
                w=6,
                h=2
            ),
            lines=[
                WidgetLineConfig(
                    name="Traces",
                    color="BLUE",
                    data_model="TRACE",
                    aggregation="COUNT",
                    filters=FilterSet(
                        operator="AND",
                        groups=[]
                    ),
                    extra_query_params={"metricMetadataKey": "tokenCount"}
                )
            ]
        )
    ],
)

result = await client.dashboards.a_create(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.dashboards.create(
  "Production overview",
  {
    description: "Traffic and latency across production.",
    private_: false,
    widgets: [
      {
        name: "Trace volume",
        description: "Traces served per day across production.",
        type: "LINE",
        unit: "COUNT",
        mode: "TIME_SERIES",
        bucketMode: "SERIES",
        dimension: "model",
        topK: {
            limit: 10,
            orderBy: "p90_latency",
            direction: "desc"
          },
        startTime: "2025-01-01T00:00:00+00:00",
        endTime: "2025-01-31T23:59:59.999000+00:00",
        layout: {
            x: 0,
            y: 0,
            w: 6,
            h: 2
          },
        lines: [
            {
              name: "Traces",
              color: "BLUE",
              dataModel: "TRACE",
              aggregation: "COUNT",
              filters: {
                  operator: "AND",
                  groups: []
                },
              extraQueryParams: { metricMetadataKey: "tokenCount" }
            }
          ]
      }
    ]
  },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.dashboards.get(dashboard_id="<DASHBOARD-ID>")

result = await client.dashboards.a_get(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.dashboards.get("<DASHBOARD-ID>");

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.dashboards.update(
    dashboard_id="<DASHBOARD-ID>",
    name="Production overview",
    description="Traffic and latency across production.",
    private=False,
)

result = await client.dashboards.a_update(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.dashboards.update(
  "<DASHBOARD-ID>",
  {
    name: "Production overview",
    description: "Traffic and latency across production.",
    private_: false
  },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.dashboards.delete(dashboard_id="<DASHBOARD-ID>")

result = await client.dashboards.a_delete(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.dashboards.delete("<DASHBOARD-ID>");

from confident_ai import ConfidentAI
from confident_ai.common import WidgetGranularity

client = ConfidentAI()

result = client.dashboards.query(
    dashboard_id="<DASHBOARD-ID>",
    start_time="2025-01-01T00:00:00+00:00",
    end_time="2025-01-31T23:59:59.999000+00:00",
    granularity=WidgetGranularity.THIRTY_MINUTES,
    widget_ids=["<WIDGET-ID>"],
)

result = await client.dashboards.a_query(...)

import { ConfidentAI } from "confident-ai";
import { WidgetGranularity } from "confident-ai/common";

const client = new ConfidentAI();

const result = await client.dashboards.query(
  "<DASHBOARD-ID>",
  {
    startTime: "2025-01-01T00:00:00+00:00",
    endTime: "2025-01-31T23:59:59.999000+00:00",
    granularity: WidgetGranularity.THIRTY_MINUTES,
    widgetIds: ["<WIDGET-ID>"]
  },
);

class CreateWidgetRequest:
    name: str
    description: Optional[str] = None
    type: Optional[WidgetType] = None
    unit: Optional[WidgetUnit] = None
    mode: Optional[WidgetMode] = None
    bucket_mode: Optional[WidgetBucketMode] = Field(default=None, alias="bucketMode")
    dimension: Optional[WidgetDimension] = None
    top_k: Optional[WidgetTopK] = Field(default=None, alias="topK")
    start_time: Optional[str] = Field(default=None, alias="startTime")
    end_time: Optional[str] = Field(default=None, alias="endTime")
    layout: Optional[WidgetLayout] = None
    lines: Optional[List[WidgetLineConfig]] = None

interface CreateWidgetRequest {
  name: string;
  description?: string | null;
  type?: WidgetType | null;
  unit?: WidgetUnit | null;
  mode?: WidgetMode | null;
  bucketMode?: WidgetBucketMode | null;
  dimension?: WidgetDimension | null;
  topK?: WidgetTopK | null;
  startTime?: string | null;
  endTime?: string | null;
  layout?: WidgetLayout | null;
  lines?: WidgetLineConfig[] | null;
}

class Dashboard:
    id: str
    name: str
    description: Optional[str]
    private: bool
    user: Optional[UserReference]
    created_at: str = Field(alias="createdAt")
    updated_at: str = Field(alias="updatedAt")
    widgets: List[Widget]

interface Dashboard {
  id: string;
  name: string;
  description: string | null;
  private: boolean;
  user: UserReference | null;
  createdAt: string;
  updatedAt: string;
  widgets: Widget[];
}

class DashboardList:
    dashboards: List[DashboardSummary]
    total_dashboards: int = Field(alias="totalDashboards")
    page: int
    page_size: int = Field(alias="pageSize")

interface DashboardList {
  dashboards: DashboardSummary[];
  totalDashboards: number;
  page: number;
  pageSize: number;
}

class DashboardQueryResult:
    results: List[DashboardWidgetQueryResult]

interface DashboardQueryResult {
  results: DashboardWidgetQueryResult[];
}

class DashboardRef:
    id: str

interface DashboardRef {
  id: string;
}

class DashboardSummary:
    id: str
    name: str
    description: Optional[str]
    private: bool
    user: Optional[UserReference]
    created_at: str = Field(alias="createdAt")
    updated_at: str = Field(alias="updatedAt")
    widget_count: int = Field(alias="widgetCount")

interface DashboardSummary {
  id: string;
  name: string;
  description: string | null;
  private: boolean;
  user: UserReference | null;
  createdAt: string;
  updatedAt: string;
  widgetCount: number;
}

DashboardWidgetQueryResult = Union[
    DashboardWidgetQuerySuccess,
    DashboardWidgetQueryFailure,
]

type DashboardWidgetQueryResult =
  | DashboardWidgetQuerySuccess
  | DashboardWidgetQueryFailure;

class FilterSet:
    operator: Literal["AND", "OR"]
    groups: List[FilterSetGroup]

interface FilterSet {
  operator: "AND" | "OR";
  groups: FilterSetGroup[];
}

class UserReference:
    id: str
    email: str
    name: Optional[str]
    image: Optional[str]

interface UserReference {
  id: string;
  email: string;
  name: string | null;
  image: string | null;
}

class Widget:
    id: str
    name: str
    description: Optional[str]
    type: Optional[WidgetType]
    unit: Optional[WidgetUnit]
    mode: Optional[WidgetMode]
    bucket_mode: Optional[WidgetBucketMode] = Field(alias="bucketMode")
    dimension: Optional[WidgetDimension]
    top_k: Optional[WidgetTopK] = Field(alias="topK")
    start_time: Optional[str] = Field(alias="startTime")
    end_time: Optional[str] = Field(alias="endTime")
    layout: Optional[WidgetLayout]
    lines: List[WidgetLine]

interface Widget {
  id: string;
  name: string;
  description: string | null;
  type: WidgetType | null;
  unit: WidgetUnit | null;
  mode: WidgetMode | null;
  bucketMode: WidgetBucketMode | null;
  dimension: WidgetDimension | null;
  topK: WidgetTopK | null;
  startTime: string | null;
  endTime: string | null;
  layout: WidgetLayout | null;
  lines: WidgetLine[];
}

class WidgetAggregation(Enum):
    AVG_COST = "AVG_COST"
    AVG_COST_PER_USER = "AVG_COST_PER_USER"
    AVG_LATENCY = "AVG_LATENCY"
    AVG_RATING = "AVG_RATING"
    AVG_SCORE = "AVG_SCORE"
    AVG_VALUE = "AVG_VALUE"
    COUNT = "COUNT"
    ERROR_COUNT = "ERROR_COUNT"
    ERROR_RATE = "ERROR_RATE"
    FAILURE_RATE = "FAILURE_RATE"
    INPUT_COST = "INPUT_COST"
    INPUT_TOKENS = "INPUT_TOKENS"
    MEDIAN_SCORE = "MEDIAN_SCORE"
    NEW_USERS = "NEW_USERS"
    OUTPUT_COST = "OUTPUT_COST"
    OUTPUT_TOKENS = "OUTPUT_TOKENS"
    P50_LATENCY = "P50_LATENCY"
    P90_LATENCY = "P90_LATENCY"
    P99_LATENCY = "P99_LATENCY"
    PASS_RATE = "PASS_RATE"
    RETENTION = "RETENTION"
    TOTAL_COST = "TOTAL_COST"
    TOTAL_TOKENS = "TOTAL_TOKENS"
    UNIQUE_END_USERS = "UNIQUE_END_USERS"
    UNIQUE_METADATA_VALUES = "UNIQUE_METADATA_VALUES"
    UNIQUE_THREADS = "UNIQUE_THREADS"
    UNIQUE_USERS = "UNIQUE_USERS"

enum WidgetAggregation {
  AVG_COST = "AVG_COST",
  AVG_COST_PER_USER = "AVG_COST_PER_USER",
  AVG_LATENCY = "AVG_LATENCY",
  AVG_RATING = "AVG_RATING",
  AVG_SCORE = "AVG_SCORE",
  AVG_VALUE = "AVG_VALUE",
  COUNT = "COUNT",
  ERROR_COUNT = "ERROR_COUNT",
  ERROR_RATE = "ERROR_RATE",
  FAILURE_RATE = "FAILURE_RATE",
  INPUT_COST = "INPUT_COST",
  INPUT_TOKENS = "INPUT_TOKENS",
  MEDIAN_SCORE = "MEDIAN_SCORE",
  NEW_USERS = "NEW_USERS",
  OUTPUT_COST = "OUTPUT_COST",
  OUTPUT_TOKENS = "OUTPUT_TOKENS",
  P50_LATENCY = "P50_LATENCY",
  P90_LATENCY = "P90_LATENCY",
  P99_LATENCY = "P99_LATENCY",
  PASS_RATE = "PASS_RATE",
  RETENTION = "RETENTION",
  TOTAL_COST = "TOTAL_COST",
  TOTAL_TOKENS = "TOTAL_TOKENS",
  UNIQUE_END_USERS = "UNIQUE_END_USERS",
  UNIQUE_METADATA_VALUES = "UNIQUE_METADATA_VALUES",
  UNIQUE_THREADS = "UNIQUE_THREADS",
  UNIQUE_USERS = "UNIQUE_USERS",
}

class WidgetBucketMode(Enum):
    SERIES = "SERIES"
    RANGE = "RANGE"

enum WidgetBucketMode {
  SERIES = "SERIES",
  RANGE = "RANGE",
}

WidgetData = Union[
    WidgetBigNumberData,
    WidgetTimeSeriesData,
    WidgetDimensionData,
    WidgetTableData,
]

type WidgetData =
  | WidgetBigNumberData
  | WidgetTimeSeriesData
  | WidgetDimensionData
  | WidgetTableData;

class WidgetDataModel(Enum):
    TRACE = "TRACE"
    SPAN = "SPAN"
    LLM_SPAN = "LLM_SPAN"
    AGENT_SPAN = "AGENT_SPAN"
    RETRIEVER_SPAN = "RETRIEVER_SPAN"
    TOOL_SPAN = "TOOL_SPAN"
    CUSTOM_SPAN = "CUSTOM_SPAN"
    THREAD = "THREAD"
    END_USER = "END_USER"
    METRIC_DATA = "METRIC_DATA"
    ANNOTATION = "ANNOTATION"
    CLASSIFICATION = "CLASSIFICATION"

enum WidgetDataModel {
  TRACE = "TRACE",
  SPAN = "SPAN",
  LLM_SPAN = "LLM_SPAN",
  AGENT_SPAN = "AGENT_SPAN",
  RETRIEVER_SPAN = "RETRIEVER_SPAN",
  TOOL_SPAN = "TOOL_SPAN",
  CUSTOM_SPAN = "CUSTOM_SPAN",
  THREAD = "THREAD",
  END_USER = "END_USER",
  METRIC_DATA = "METRIC_DATA",
  ANNOTATION = "ANNOTATION",
  CLASSIFICATION = "CLASSIFICATION",
}

class WidgetDimension(Enum):
    PROJECT = "project"
    TRACE_NAME = "trace_name"
    SPAN_NAME = "span_name"
    MODEL = "model"
    TYPE = "type"
    THREAD_ID = "thread_id"
    TEST_CASE_ID = "test_case_id"
    TEST_RUN_ID = "test_run_id"
    END_USER = "end_user"
    CUSTOMER = "customer"
    SOURCE = "source"
    ANNOTATOR = "annotator"
    NAME = "name"
    ERROR = "error"
    PROMPT_ALIAS = "prompt_alias"
    TAG = "tag"
    LABEL = "label"
    EVALUATION_MODEL = "evaluation_model"
    PROMPT_VERSION = "prompt_version"
    PROMPT_LABEL = "prompt_label"
    PROMPT_COMMIT_HASH = "prompt_commit_hash"
    METADATA = "metadata"
    HYPERPARAMETER = "hyperparameter"
    CLASSIFIER = "classifier"
    POLARITY = "polarity"
    CLASSIFIER_LABEL = "classifier_label"
    VERSION = "version"
    VALUE = "value"
    FAILURE_SUB_MODE = "failure_sub_mode"

enum WidgetDimension {
  PROJECT = "project",
  TRACE_NAME = "trace_name",
  SPAN_NAME = "span_name",
  MODEL = "model",
  TYPE = "type",
  THREAD_ID = "thread_id",
  TEST_CASE_ID = "test_case_id",
  TEST_RUN_ID = "test_run_id",
  END_USER = "end_user",
  CUSTOMER = "customer",
  SOURCE = "source",
  ANNOTATOR = "annotator",
  NAME = "name",
  ERROR = "error",
  PROMPT_ALIAS = "prompt_alias",
  TAG = "tag",
  LABEL = "label",
  EVALUATION_MODEL = "evaluation_model",
  PROMPT_VERSION = "prompt_version",
  PROMPT_LABEL = "prompt_label",
  PROMPT_COMMIT_HASH = "prompt_commit_hash",
  METADATA = "metadata",
  HYPERPARAMETER = "hyperparameter",
  CLASSIFIER = "classifier",
  POLARITY = "polarity",
  CLASSIFIER_LABEL = "classifier_label",
  VERSION = "version",
  VALUE = "value",
  FAILURE_SUB_MODE = "failure_sub_mode",
}

class WidgetGranularity(Enum):
    THIRTY_MINUTES = "thirty_minutes"
    HOUR = "hour"
    DAY = "day"
    WEEK = "week"
    MONTH = "month"

enum WidgetGranularity {
  THIRTY_MINUTES = "thirty_minutes",
  HOUR = "hour",
  DAY = "day",
  WEEK = "week",
  MONTH = "month",
}

class WidgetLayout:
    x: float
    y: float
    w: float
    h: float

interface WidgetLayout {
  x: number;
  y: number;
  w: number;
  h: number;
}

class WidgetLine:
    id: str
    name: str
    color: WidgetLineColor
    data_model: Optional[WidgetDataModel] = Field(alias="dataModel")
    aggregation: Optional[WidgetAggregation]
    filters: Optional[FilterSet]
    extra_query_params: Optional[WidgetLineExtraQueryParams] = Field(alias="extraQueryParams")

interface WidgetLine {
  id: string;
  name: string;
  color: WidgetLineColor;
  dataModel: WidgetDataModel | null;
  aggregation: WidgetAggregation | null;
  filters: FilterSet | null;
  extraQueryParams: WidgetLineExtraQueryParams | null;
}

class WidgetLineColor(Enum):
    AMBER = "AMBER"
    VIOLET = "VIOLET"
    EMERALD = "EMERALD"
    BLUE = "BLUE"
    PINK = "PINK"
    CYAN = "CYAN"
    ROSE = "ROSE"
    LIME = "LIME"
    TEAL = "TEAL"
    ORANGE = "ORANGE"

enum WidgetLineColor {
  AMBER = "AMBER",
  VIOLET = "VIOLET",
  EMERALD = "EMERALD",
  BLUE = "BLUE",
  PINK = "PINK",
  CYAN = "CYAN",
  ROSE = "ROSE",
  LIME = "LIME",
  TEAL = "TEAL",
  ORANGE = "ORANGE",
}

class WidgetLineConfig:
    name: str
    color: Optional[WidgetLineColor] = None
    data_model: Optional[WidgetDataModel] = Field(default=None, alias="dataModel")
    aggregation: Optional[WidgetAggregation] = None
    filters: Optional[FilterSet] = None
    extra_query_params: Optional[WidgetLineExtraQueryParams] = Field(default=None, alias="extraQueryParams")

interface WidgetLineConfig {
  name: string;
  color?: WidgetLineColor | null;
  dataModel?: WidgetDataModel | null;
  aggregation?: WidgetAggregation | null;
  filters?: FilterSet | null;
  extraQueryParams?: WidgetLineExtraQueryParams | null;
}

class WidgetMode(Enum):
    TIME_SERIES = "TIME_SERIES"
    DIMENSION_SERIES = "DIMENSION_SERIES"

enum WidgetMode {
  TIME_SERIES = "TIME_SERIES",
  DIMENSION_SERIES = "DIMENSION_SERIES",
}

class WidgetQueryError:
    code: Literal["QUERY_FAILED"]
    message: str

interface WidgetQueryError {
  code: "QUERY_FAILED";
  message: string;
}

class WidgetScalarValue:
    key: str
    name: str
    color: WidgetLineColor
    line_id: Optional[str] = Field(default=None, alias="lineId")
    value: Optional[float]

interface WidgetScalarValue {
  key: string;
  name: string;
  color: WidgetLineColor;
  lineId?: string;
  value: number | null;
}

class WidgetSeries:
    key: str
    name: str
    color: WidgetLineColor
    line_id: Optional[str] = Field(default=None, alias="lineId")
    points: List[WidgetSeriesPoint]

interface WidgetSeries {
  key: string;
  name: string;
  color: WidgetLineColor;
  lineId?: string;
  points: WidgetSeriesPoint[];
}

class WidgetSeriesPoint:
    x: str
    y: Optional[float]

interface WidgetSeriesPoint {
  x: string;
  y: number | null;
}

class WidgetTableColumn:
    key: str
    label: str

interface WidgetTableColumn {
  key: string;
  label: string;
}

class WidgetTopK:
    limit: Optional[int] = None
    order_by: Optional[Literal["count", "avg_latency", "p50_latency", "p90_latency", "p99_latency", "error_rate", "pass_rate", "failure_rate", "input_cost", "output_cost", "total_cost", "avg_cost", "input_tokens", "output_tokens", "total_tokens", "count_distinct_endUserId", "count_distinct_threadId", "count_distinct_model", "count_distinct_projectId", "count_distinct_error", "count_distinct_metadata", "error_count", "pass_count", "avg_score", "stddev_score", "median_score", "avg_rating", "avg_value", "score_histogram", "created_at", "start_time", "dimension"]] = Field(default=None, alias="orderBy")
    direction: Optional[Literal["asc", "desc"]] = None

interface WidgetTopK {
  limit?: number;
  orderBy?: "count" | "avg_latency" | "p50_latency" | "p90_latency" | "p99_latency" | "error_rate" | "pass_rate" | "failure_rate" | "input_cost" | "output_cost" | "total_cost" | "avg_cost" | "input_tokens" | "output_tokens" | "total_tokens" | "count_distinct_endUserId" | "count_distinct_threadId" | "count_distinct_model" | "count_distinct_projectId" | "count_distinct_error" | "count_distinct_metadata" | "error_count" | "pass_count" | "avg_score" | "stddev_score" | "median_score" | "avg_rating" | "avg_value" | "score_histogram" | "created_at" | "start_time" | "dimension";
  direction?: "asc" | "desc";
}

class WidgetType(Enum):
    LINE = "LINE"
    AREA = "AREA"
    BAR = "BAR"
    STACKED_BAR = "STACKED_BAR"
    GROUPED_BAR = "GROUPED_BAR"
    TABLE = "TABLE"
    BIG_NUMBER = "BIG_NUMBER"

enum WidgetType {
  LINE = "LINE",
  AREA = "AREA",
  BAR = "BAR",
  STACKED_BAR = "STACKED_BAR",
  GROUPED_BAR = "GROUPED_BAR",
  TABLE = "TABLE",
  BIG_NUMBER = "BIG_NUMBER",
}

class WidgetUnit(Enum):
    COUNT = "COUNT"
    PERCENT = "PERCENT"
    SCORE = "SCORE"
    SECONDS = "SECONDS"
    USD = "USD"
    MILLISECONDS = "MILLISECONDS"

enum WidgetUnit {
  COUNT = "COUNT",
  PERCENT = "PERCENT",
  SCORE = "SCORE",
  SECONDS = "SECONDS",
  USD = "USD",
  MILLISECONDS = "MILLISECONDS",
}