@iblai/iblai-api 4.261.0-core → 4.261.1-ai

package/src/services/EvaluationsService.ts

@@ -0,0 +1,869 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Dataset } from '../models/Dataset';
+import type { DatasetCreate } from '../models/DatasetCreate';
+import type { DatasetItem } from '../models/DatasetItem';
+import type { DatasetItemBulkCreateResponse } from '../models/DatasetItemBulkCreateResponse';
+import type { DatasetItemCreate } from '../models/DatasetItemCreate';
+import type { DatasetItemUpdate } from '../models/DatasetItemUpdate';
+import type { ExperimentCreate } from '../models/ExperimentCreate';
+import type { JudgeRecord } from '../models/JudgeRecord';
+import type { LLMJudge } from '../models/LLMJudge';
+import type { PaginatedDatasetItemList } from '../models/PaginatedDatasetItemList';
+import type { PaginatedDatasetList } from '../models/PaginatedDatasetList';
+import type { PaginatedJudgeList } from '../models/PaginatedJudgeList';
+import type { PaginatedRunList } from '../models/PaginatedRunList';
+import type { PaginatedScoreConfigList } from '../models/PaginatedScoreConfigList';
+import type { PaginatedScoreList } from '../models/PaginatedScoreList';
+import type { Run } from '../models/Run';
+import type { RunDetailResponse } from '../models/RunDetailResponse';
+import type { ScoreConfig } from '../models/ScoreConfig';
+import type { ScoreConfigCreate } from '../models/ScoreConfigCreate';
+import type { ScoreCreate } from '../models/ScoreCreate';
+import type { ScoreCreateResponse } from '../models/ScoreCreateResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class EvaluationsService {
+    /**
+     * List datasets
+     * List datasets belonging to the tenant. Supports server-side filtering by name substring and creator email (matched against the cached `created_by_email` in Langfuse metadata).
+     * @returns PaginatedDatasetList
+     * @throws ApiError
+     */
+    public static evaluationsDatasetsList({
+        org,
+        userId,
+        limit,
+        name,
+        page,
+        userEmail,
+    }: {
+        org: string,
+        userId: string,
+        /**
+         * Page size (max 200).
+         */
+        limit?: number,
+        /**
+         * Case-insensitive substring match on the dataset name.
+         */
+        name?: string,
+        /**
+         * Page number (1-indexed).
+         */
+        page?: number,
+        /**
+         * Filter datasets created by this user (exact match).
+         */
+        userEmail?: string,
+    }): CancelablePromise<PaginatedDatasetList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'limit': limit,
+                'name': name,
+                'page': page,
+                'user_email': userEmail,
+            },
+        });
+    }
+    /**
+     * Create a dataset
+     * Create a Langfuse dataset under the tenant. The creator's `username` and `user_email` are captured into metadata so future list responses can attribute the row without an extra DB lookup.
+     * @returns Dataset
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsCreate({
+        org,
+        userId,
+        requestBody,
+    }: {
+        org: string,
+        userId: string,
+        requestBody: DatasetCreate,
+    }): CancelablePromise<Dataset> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error.`,
+            },
+        });
+    }
+    /**
+     * Retrieve a dataset
+     * Get a single dataset by name.
+     * @returns Dataset
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsRetrieve({
+        datasetName,
+        org,
+        userId,
+    }: {
+        datasetName: string,
+        org: string,
+        userId: string,
+    }): CancelablePromise<Dataset> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'user_id': userId,
+            },
+            errors: {
+                403: `Authenticated, but the resource belongs to another tenant.`,
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * List dataset items
+     * List items in a dataset. Pass `?include_trace=true` to attach `trace_input` / `trace_output` for items linked to a source trace (one bulk ClickHouse query for the page — no per-row fan-out).
+     * @returns PaginatedDatasetItemList
+     * @throws ApiError
+     */
+    public static evaluationsDatasetItemsList({
+        datasetName,
+        org,
+        userId,
+        includeTrace,
+        limit,
+        page,
+        status,
+    }: {
+        datasetName: string,
+        org: string,
+        userId: string,
+        /**
+         * When true, populate `trace_input` / `trace_output` from the linked trace for items that have a `source_trace_id`.
+         */
+        includeTrace?: boolean,
+        /**
+         * Page size (max 200).
+         */
+        limit?: number,
+        /**
+         * Page number (1-indexed).
+         */
+        page?: number,
+        /**
+         * Filter by dataset item status (exact match).
+         */
+        status?: 'ACTIVE' | 'ARCHIVED',
+    }): CancelablePromise<PaginatedDatasetItemList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/items/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'include_trace': includeTrace,
+                'limit': limit,
+                'page': page,
+                'status': status,
+            },
+            errors: {
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Add dataset items
+     * Add items to a dataset. Provide either an `items` array of `{input, expected_output}` objects OR a `trace_ids` array to seed items from existing traces (input/expected are then copied from the trace). Exactly one of the two must be present.
+     * @returns DatasetItemBulkCreateResponse
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsItemsCreate({
+        datasetName,
+        org,
+        userId,
+        requestBody,
+    }: {
+        datasetName: string,
+        org: string,
+        userId: string,
+        requestBody?: DatasetItemCreate,
+    }): CancelablePromise<DatasetItemBulkCreateResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/items/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error.`,
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Retrieve a dataset item
+     * Retrieve a single dataset item. `trace_input` / `trace_output` are always populated when the item has a `source_trace_id` (single-row case, no fan-out concern).
+     * @returns DatasetItem
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsItemsRetrieve({
+        datasetName,
+        itemId,
+        org,
+        userId,
+    }: {
+        datasetName: string,
+        itemId: string,
+        org: string,
+        userId: string,
+    }): CancelablePromise<DatasetItem> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/items/{item_id}/',
+            path: {
+                'dataset_name': datasetName,
+                'item_id': itemId,
+                'org': org,
+                'user_id': userId,
+            },
+            errors: {
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Update a dataset item
+     * Update any subset of `input`, `expected_output`, `metadata`, or `status` on a dataset item. Uses Langfuse's id-based upsert.
+     * @returns DatasetItem
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsItemsUpdate({
+        datasetName,
+        itemId,
+        org,
+        userId,
+        requestBody,
+    }: {
+        datasetName: string,
+        itemId: string,
+        org: string,
+        userId: string,
+        requestBody?: DatasetItemUpdate,
+    }): CancelablePromise<DatasetItem> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/items/{item_id}/',
+            path: {
+                'dataset_name': datasetName,
+                'item_id': itemId,
+                'org': org,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error.`,
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Delete a dataset item
+     * Queues the item for deletion in Langfuse. List/get endpoints hide this id immediately, but Langfuse's worker can take up to a few minutes to remove it from its own stores.
+     * @returns any Deletion queued.
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsItemsDestroy({
+        datasetName,
+        itemId,
+        org,
+        userId,
+    }: {
+        datasetName: string,
+        itemId: string,
+        org: string,
+        userId: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/items/{item_id}/',
+            path: {
+                'dataset_name': datasetName,
+                'item_id': itemId,
+                'org': org,
+                'user_id': userId,
+            },
+            errors: {
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Upload a CSV of dataset items
+     * Bulk-create items from a CSV (multipart `file` field). The CSV must have an `input` column; `expected_output` is optional. Rows with empty `input` are skipped.
+     * @returns DatasetItemBulkCreateResponse
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsItemsUploadCreate({
+        datasetName,
+        org,
+        userId,
+        formData,
+    }: {
+        datasetName: string,
+        org: string,
+        userId: string,
+        formData?: {
+            file: Blob;
+        },
+    }): CancelablePromise<DatasetItemBulkCreateResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/items/upload/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'user_id': userId,
+            },
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                400: `Validation error.`,
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * List experiment runs
+     * List runs for a dataset. The response merges Langfuse-persisted runs with in-flight `EvaluationTaskRecord` rows (status `pending` / `in_progress`), deduplicated by `run_name`. `pending_count` reports how many pending entries are in the page so the UI can badge in-flight work.
+     * @returns PaginatedRunList
+     * @throws ApiError
+     */
+    public static evaluationsRunsList({
+        datasetName,
+        org,
+        userId,
+        limit,
+        name,
+        page,
+        userEmail,
+    }: {
+        datasetName: string,
+        org: string,
+        userId: string,
+        /**
+         * Page size (max 200).
+         */
+        limit?: number,
+        /**
+         * Case-insensitive substring match on the run name. Applies to both pending records and Langfuse-persisted runs.
+         */
+        name?: string,
+        /**
+         * Page number (1-indexed).
+         */
+        page?: number,
+        /**
+         * Filter by the initiator's email. Applies to both pending records and Langfuse-persisted runs.
+         */
+        userEmail?: string,
+    }): CancelablePromise<PaginatedRunList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/runs/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'limit': limit,
+                'name': name,
+                'page': page,
+                'user_email': userEmail,
+            },
+            errors: {
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Start an experiment run
+     * Dispatch a Celery task that runs the chosen mentor against every item in the dataset. Returns immediately (HTTP 202) with the new task record. Poll the list endpoint (or the run-detail endpoint once Langfuse persists the run) to watch the `pending → in_progress → completed` transition.
+     * @returns Run
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsRunsCreate({
+        datasetName,
+        org,
+        userId,
+        requestBody,
+    }: {
+        datasetName: string,
+        org: string,
+        userId: string,
+        requestBody: ExperimentCreate,
+    }): CancelablePromise<Run> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/runs/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error.`,
+                404: `Dataset or mentor not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Retrieve experiment run details
+     * Returns the run header plus every `dataset_run_item` fully expanded with `input`, `expected_output`, `actual_output`, `trace_id`, and per-item `scores`. Also embeds a `pending_judges` array for any in-flight LLM-as-Judge evaluations against this run.
+     *
+     * Cost: 1 PG query + 2 ClickHouse queries + 1 score query regardless of run size.
+     * @returns RunDetailResponse
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsRunsRetrieve({
+        datasetName,
+        org,
+        runName,
+        userId,
+    }: {
+        datasetName: string,
+        org: string,
+        runName: string,
+        userId: string,
+    }): CancelablePromise<RunDetailResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/runs/{run_name}/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'run_name': runName,
+                'user_id': userId,
+            },
+            errors: {
+                403: `Authenticated, but the resource belongs to another tenant.`,
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Delete an experiment run
+     * Queues the run for deletion in Langfuse. List/get endpoints hide this run immediately, but Langfuse's worker can take up to a few minutes to remove it from its own stores.
+     * @returns any Deletion queued.
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsRunsDestroy({
+        datasetName,
+        org,
+        runName,
+        userId,
+    }: {
+        datasetName: string,
+        org: string,
+        runName: string,
+        userId: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/runs/{run_name}/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'run_name': runName,
+                'user_id': userId,
+            },
+            errors: {
+                403: `Authenticated, but the resource belongs to another tenant.`,
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * List LLM-as-Judge evaluations for a run
+     * Returns every judge task record (any status) targeting this run. Useful for showing an 'Evaluations' history on a run-detail view, including failed and pending ones.
+     * @returns PaginatedJudgeList
+     * @throws ApiError
+     */
+    public static evaluationsRunJudgesList({
+        datasetName,
+        org,
+        runName,
+        userId,
+        limit,
+        page,
+        status,
+        userEmail,
+    }: {
+        datasetName: string,
+        org: string,
+        runName: string,
+        userId: string,
+        /**
+         * Page size (max 200).
+         */
+        limit?: number,
+        /**
+         * Page number (1-indexed).
+         */
+        page?: number,
+        /**
+         * Filter by task status.
+         */
+        status?: 'completed' | 'failed' | 'in_progress' | 'pending',
+        /**
+         * Filter by the initiator's email.
+         */
+        userEmail?: string,
+    }): CancelablePromise<PaginatedJudgeList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/runs/{run_name}/evaluate/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'run_name': runName,
+                'user_id': userId,
+            },
+            query: {
+                'limit': limit,
+                'page': page,
+                'status': status,
+                'user_email': userEmail,
+            },
+        });
+    }
+    /**
+     * Start an LLM-as-Judge evaluation
+     * Dispatch a Celery task that runs a separate LLM over every item in the run, scoring the actual output against the input + expected output using the provided criteria. The judge's score lands in Langfuse with `score_name`, and its reasoning is stored in the score's `comment`.
+     *
+     * Returns immediately (HTTP 202) with the new task record. The task transitions through `pending → in_progress → completed` (or `failed`); poll the list endpoint or the run-detail endpoint to watch.
+     * @returns JudgeRecord
+     * @throws ApiError
+     */
+    public static evaluationsRunJudgeCreate({
+        datasetName,
+        org,
+        runName,
+        userId,
+        requestBody,
+    }: {
+        datasetName: string,
+        org: string,
+        runName: string,
+        userId: string,
+        requestBody: LLMJudge,
+    }): CancelablePromise<JudgeRecord> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/runs/{run_name}/evaluate/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'run_name': runName,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Empty run or invalid input.`,
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * Export experiment results as CSV
+     * Download the run as a CSV. Columns: `item_id`, `input`, `expected_output`, `trace_id`, `actual_output`, and one `score_<name>` column per distinct score name in the run.
+     * @returns binary CSV file download.
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsDatasetsRunsExportRetrieve({
+        datasetName,
+        org,
+        runName,
+        userId,
+    }: {
+        datasetName: string,
+        org: string,
+        runName: string,
+        userId: string,
+    }): CancelablePromise<Blob> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/datasets/{dataset_name}/runs/{run_name}/export/',
+            path: {
+                'dataset_name': datasetName,
+                'org': org,
+                'run_name': runName,
+                'user_id': userId,
+            },
+            errors: {
+                403: `Authenticated, but the resource belongs to another tenant.`,
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+    /**
+     * List LLM-as-Judge evaluations (tenant-wide)
+     * Returns every judge task record in the tenant, across all datasets and runs. Useful for a tenant-wide 'Evaluations' inbox.
+     * @returns PaginatedJudgeList
+     * @throws ApiError
+     */
+    public static evaluationsJudgesGlobalList({
+        org,
+        userId,
+        datasetName,
+        limit,
+        page,
+        status,
+        userEmail,
+    }: {
+        org: string,
+        userId: string,
+        /**
+         * Restrict to one dataset.
+         */
+        datasetName?: string,
+        /**
+         * Page size (max 200).
+         */
+        limit?: number,
+        /**
+         * Page number (1-indexed).
+         */
+        page?: number,
+        /**
+         * Filter by task status.
+         */
+        status?: 'completed' | 'failed' | 'in_progress' | 'pending',
+        /**
+         * Filter by the initiator's email.
+         */
+        userEmail?: string,
+    }): CancelablePromise<PaginatedJudgeList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/judges/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'dataset_name': datasetName,
+                'limit': limit,
+                'page': page,
+                'status': status,
+                'user_email': userEmail,
+            },
+        });
+    }
+    /**
+     * List score configurations
+     * Score configurations define reusable rubrics (numeric ranges, boolean, or categorical labels). They are optional — scores work without one — but useful for enforcing consistent grading.
+     * @returns PaginatedScoreConfigList
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsScoreConfigsRetrieve({
+        org,
+        userId,
+        limit,
+        page,
+    }: {
+        org: string,
+        userId: string,
+        /**
+         * Page size (max 200).
+         */
+        limit?: number,
+        /**
+         * Page number (1-indexed).
+         */
+        page?: number,
+    }): CancelablePromise<PaginatedScoreConfigList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/score-configs/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'limit': limit,
+                'page': page,
+            },
+        });
+    }
+    /**
+     * Create a score configuration
+     * Create a score configuration.
+     * @returns ScoreConfig
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsScoreConfigsCreate({
+        org,
+        userId,
+        requestBody,
+    }: {
+        org: string,
+        userId: string,
+        requestBody: ScoreConfigCreate,
+    }): CancelablePromise<ScoreConfig> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/score-configs/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error.`,
+            },
+        });
+    }
+    /**
+     * List scores
+     * List scores (human annotations and LLM-judge results) with optional filters. Pair `dataset_run_id` with a run id to scope to one experiment; pass `trace_id` to scope to a single chat turn or mentor invocation.
+     * @returns PaginatedScoreList
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsScoresRetrieve({
+        org,
+        userId,
+        datasetRunId,
+        limit,
+        name,
+        page,
+        traceId,
+        userEmail,
+    }: {
+        org: string,
+        userId: string,
+        /**
+         * Restrict to scores attached to this Langfuse run.
+         */
+        datasetRunId?: string,
+        /**
+         * Page size (max 200).
+         */
+        limit?: number,
+        /**
+         * Filter by score name (exact match).
+         */
+        name?: string,
+        /**
+         * Page number (1-indexed).
+         */
+        page?: number,
+        /**
+         * Restrict to scores on this trace. The same id is exposed as `generation_id` in WebSocket chat frames.
+         */
+        traceId?: string,
+        /**
+         * Filter by the score creator's email (matched against the `created_by_email` key in score metadata).
+         */
+        userEmail?: string,
+    }): CancelablePromise<PaginatedScoreList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/scores/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'dataset_run_id': datasetRunId,
+                'limit': limit,
+                'name': name,
+                'page': page,
+                'trace_id': traceId,
+                'user_email': userEmail,
+            },
+        });
+    }
+    /**
+     * Create a score
+     * Create a score on a trace or observation. Use this to record human grading of a single chat message (pass the chat frame's `generation_id` as `trace_id`) or to score an experiment-run item (also pass `dataset_run_id` so the score shows up in the run's CSV export).
+     * @returns ScoreCreateResponse
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsScoresCreate({
+        org,
+        userId,
+        requestBody,
+    }: {
+        org: string,
+        userId: string,
+        requestBody: ScoreCreate,
+    }): CancelablePromise<ScoreCreateResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/scores/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Validation error.`,
+            },
+        });
+    }
+    /**
+     * Delete a score
+     * Queues the score for deletion in Langfuse. The list endpoint hides this id immediately, but Langfuse's worker can take up to a few minutes to remove it from its own stores.
+     * @returns any Deletion queued.
+     * @throws ApiError
+     */
+    public static aiMentorOrgsUsersEvaluationsScoresDestroy({
+        org,
+        scoreId,
+        userId,
+    }: {
+        org: string,
+        scoreId: string,
+        userId: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/evaluations/scores/{score_id}/',
+            path: {
+                'org': org,
+                'score_id': scoreId,
+                'user_id': userId,
+            },
+            errors: {
+                404: `Not found within the tenant.`,
+            },
+        });
+    }
+}