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

package/dist/types/services/CoreService.d.ts

@@ -36,6 +36,7 @@ import type { PlatformConfigurationSetResponse } from '../models/PlatformConfigu
 import type { PlatformList } from '../models/PlatformList';
 import type { PlatformMembershipConfig } from '../models/PlatformMembershipConfig';
 import type { PlatformMembershipConfigPostRequest } from '../models/PlatformMembershipConfigPostRequest';
+import type { PlatformMembershipConfigPublicResponse } from '../models/PlatformMembershipConfigPublicResponse';
 import type { PlatformPublicImageAsset } from '../models/PlatformPublicImageAsset';
 import type { PlatformPublicMetadata } from '../models/PlatformPublicMetadata';
 import type { PlatformUpdatePostRequest } from '../models/PlatformUpdatePostRequest';
@@ -1597,6 +1598,17 @@ export declare class CoreService {
     static coreUsersPlatformsConfigCreate({ requestBody, }: {
         requestBody: PlatformMembershipConfigPostRequest;
     }): CancelablePromise<PlatformMembershipConfig>;
+    /**
+     * Anonymous read of public per-platform membership config.
+     *
+     * Query params:
+     * platform_key: The key of the platform to look up.
+     * @returns PlatformMembershipConfigPublicResponse
+     * @throws ApiError
+     */
+    static coreUsersPlatformsConfigPublicRetrieve({ platformKey, }: {
+        platformKey: string;
+    }): CancelablePromise<PlatformMembershipConfigPublicResponse>;
     /**
      * Allow authenticated users to self-link to platforms that have self-linking enabled
      *

package/dist/types/services/EvaluationsService.d.ts

@@ -0,0 +1,365 @@
+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';
+export declare 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
+     */
+    static evaluationsDatasetsList({ org, userId, limit, name, page, userEmail, }: {
+        org: 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>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsCreate({ org, userId, requestBody, }: {
+        org: string;
+        requestBody: DatasetCreate;
+    }): CancelablePromise<Dataset>;
+    /**
+     * Retrieve a dataset
+     * Get a single dataset by name.
+     * @returns Dataset
+     * @throws ApiError
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsRetrieve({ datasetName, org, userId, }: {
+        datasetName: string;
+        org: string;
+    }): CancelablePromise<Dataset>;
+    /**
+     * 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
+     */
+    static evaluationsDatasetItemsList({ datasetName, org, userId, includeTrace, limit, page, status, }: {
+        datasetName: string;
+        org: 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>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsItemsCreate({ datasetName, org, userId, requestBody, }: {
+        datasetName: string;
+        org: string;
+        requestBody?: DatasetItemCreate;
+    }): CancelablePromise<DatasetItemBulkCreateResponse>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsItemsRetrieve({ datasetName, itemId, org, userId, }: {
+        datasetName: string;
+        itemId: string;
+        org: string;
+    }): CancelablePromise<DatasetItem>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsItemsUpdate({ datasetName, itemId, org, userId, requestBody, }: {
+        datasetName: string;
+        itemId: string;
+        org: string;
+        requestBody?: DatasetItemUpdate;
+    }): CancelablePromise<DatasetItem>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsItemsDestroy({ datasetName, itemId, org, userId, }: {
+        datasetName: string;
+        itemId: string;
+        org: string;
+    }): CancelablePromise<any>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsItemsUploadCreate({ datasetName, org, userId, formData, }: {
+        datasetName: string;
+        org: string;
+        formData?: {
+            file: Blob;
+        };
+    }): CancelablePromise<DatasetItemBulkCreateResponse>;
+    /**
+     * 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
+     */
+    static evaluationsRunsList({ datasetName, org, userId, limit, name, page, userEmail, }: {
+        datasetName: string;
+        org: 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>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsRunsCreate({ datasetName, org, userId, requestBody, }: {
+        datasetName: string;
+        org: string;
+        requestBody: ExperimentCreate;
+    }): CancelablePromise<Run>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsRunsRetrieve({ datasetName, org, runName, userId, }: {
+        datasetName: string;
+        org: string;
+        runName: string;
+    }): CancelablePromise<RunDetailResponse>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsRunsDestroy({ datasetName, org, runName, userId, }: {
+        datasetName: string;
+        org: string;
+        runName: string;
+    }): CancelablePromise<any>;
+    /**
+     * 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
+     */
+    static evaluationsRunJudgesList({ datasetName, org, runName, userId, limit, page, status, userEmail, }: {
+        datasetName: string;
+        org: string;
+        runName: 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>;
+    /**
+     * 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
+     */
+    static evaluationsRunJudgeCreate({ datasetName, org, runName, userId, requestBody, }: {
+        datasetName: string;
+        org: string;
+        runName: string;
+        requestBody: LLMJudge;
+    }): CancelablePromise<JudgeRecord>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsDatasetsRunsExportRetrieve({ datasetName, org, runName, userId, }: {
+        datasetName: string;
+        org: string;
+        runName: string;
+    }): CancelablePromise<Blob>;
+    /**
+     * 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
+     */
+    static evaluationsJudgesGlobalList({ org, userId, datasetName, limit, page, status, userEmail, }: {
+        org: 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>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsScoreConfigsRetrieve({ org, userId, limit, page, }: {
+        org: string; /**
+         * Page size (max 200).
+         */
+        limit?: number;
+        /**
+         * Page number (1-indexed).
+         */
+        page?: number;
+    }): CancelablePromise<PaginatedScoreConfigList>;
+    /**
+     * Create a score configuration
+     * Create a score configuration.
+     * @returns ScoreConfig
+     * @throws ApiError
+     */
+    static aiMentorOrgsUsersEvaluationsScoreConfigsCreate({ org, userId, requestBody, }: {
+        org: string;
+        requestBody: ScoreConfigCreate;
+    }): CancelablePromise<ScoreConfig>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsScoresRetrieve({ org, userId, datasetRunId, limit, name, page, traceId, userEmail, }: {
+        org: 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>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsScoresCreate({ org, userId, requestBody, }: {
+        org: string;
+        requestBody: ScoreCreate;
+    }): CancelablePromise<ScoreCreateResponse>;
+    /**
+     * 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
+     */
+    static aiMentorOrgsUsersEvaluationsScoresDestroy({ org, scoreId, userId, }: {
+        org: string;
+        scoreId: string;
+    }): CancelablePromise<any>;
+}

package/dist/types/services/IntegrationCredentialsService.d.ts

@@ -0,0 +1,26 @@
+import type { IntegrationCredentialSchemaV2 } from '../models/IntegrationCredentialSchemaV2';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class IntegrationCredentialsService {
+    /**
+     * Retrieve V2 integration credentials schema with sensitivity metadata.
+     *
+     * Query Parameters:
+     * name (optional): Filter results by integration service name
+     *
+     * Args:
+     * request: The HTTP request
+     * org: Organization key identifier
+     *
+     * Returns:
+     * Response: List of integration credentials schema with is_sensitive metadata.
+     * @returns IntegrationCredentialSchemaV2
+     * @throws ApiError
+     */
+    static aiAccountOrgsIntegrationCredentialSchemaV2List({ org, name, }: {
+        org: string;
+        /**
+         * Filter credentials by provider name (e.g., 'openai', 'google')
+         */
+        name?: string;
+    }): CancelablePromise<Array<IntegrationCredentialSchemaV2>>;
+}