@thinkai/tai-api-contract 2.170.0 → 2.172.0

package/dist/generated/openapi.d.ts

@@ -66,6 +66,27 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/admin/assessment-manifest-validation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Validate an assessment manifest before export
+         * @description Runs the fail-closed manifest check for one sold assessment. The server ignores `manifest.validation` and `manifest.watermark` from the client. `buyerDeliverable` is true only when the result is validated and `shareMode` is internal. An external share-safe result can be validated and is never the buyer file. Unset or exceeded tolerances fail. No numeric tolerance is assumed. GitLab and Bitbucket fixtures are not part of this operation.
+         *     **Authorization:** Bearer JWT required. Caller email must appear in `PLATFORM_ADMIN_EMAILS`.
+         */
+        post: operations["runAssessmentManifestValidation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/admin/readiness/token-usage": {
         parameters: {
             query?: never;
@@ -4764,6 +4785,118 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/workspaces/{workspaceId}/evals/suites": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List eval suites for a workspace
+         * @description Returns the latest version of each eval suite in the workspace (max 50 suites). Requires workspace membership (`requireWorkspaceMember`). Empty workspace → `{ "suites": [] }`.
+         */
+        get: operations["listEvalSuites"];
+        put?: never;
+        /**
+         * Create an eval suite
+         * @description Creates a suite at `version: 1`. Requires workspace editor or admin (`requireWorkspaceEditor`). Rejects when both `target.promptBody` is empty and model fields are missing; when `cases` is empty (`400` `eval_suite_cases_required`); or when the workspace already has 50 suites. Each case must include at least one expected signal.
+         */
+        post: operations["createEvalSuite"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/evals/suites/{suiteId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get an eval suite (latest version)
+         * @description Returns the latest version of the suite. Historical versions are retained for runs via `suiteVersion` + snapshot on each run; this endpoint does not expose prior versions. Requires workspace membership.
+         */
+        get: operations["getEvalSuite"];
+        /**
+         * Update an eval suite
+         * @description Replaces mutable suite fields. Requires workspace editor or admin. Changing `target`, `cases`, or `promptBody` increments `version` by 1 and keeps prior versions immutable for historical runs. Cosmetic name/description-only updates do not bump `version`. Same validation rules as create (cases required, target required, bounds).
+         */
+        put: operations["updateEvalSuite"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/evals/suites/{suiteId}/runs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List recent eval runs for a suite
+         * @description Returns the last 50 runs for the suite (newest first). Empty → `{ "runs": [] }`. Requires workspace membership. Does not trigger scoring.
+         */
+        get: operations["listEvalRuns"];
+        put?: never;
+        /**
+         * Enqueue an eval suite run
+         * @description Enqueues an async eval run. Returns `202` with `{ runId, status: "queued" }`. Never scores on the request path — a worker claims the run, uses `fixtureCompletion` when present (or live completion when provider credentials exist), applies deterministic expected-signal scoring, and persists results. Requires workspace editor or admin. At most one active (`queued`|`running`) run per suite; a second POST returns `409` `eval_run_in_progress`.
+         */
+        post: operations["enqueueEvalRun"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/evals/suites/{suiteId}/runs/{runId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get an eval run with case results
+         * @description Returns persisted run status and case results. While `queued` or `running`, `caseResults` may be empty and `score` null. Requires workspace membership. Does not trigger scoring.
+         */
+        get: operations["getEvalRun"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/workspaces/{workspaceId}/evals/insights": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Eval insights (regressions, tips, efficiency, model comparison)
+         * @description Workspace-level Insights for prompt/model evals. Computes regressions when prior score − current score ≥ 0.10 on the same suiteId+suiteVersion case set (or suite score drop ≥ 0.10); prompt tips from failed signal notes / case names; token efficiency averages over successful cases in the last succeeded run per suite; and model comparison rollups. No succeeded runs → empty arrays and null `tokenEfficiency`. Requires workspace membership. Distinct from `/insights-recommendations` and AI Usage & Spend.
+         */
+        get: operations["getEvalInsights"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -10998,6 +11131,203 @@ export interface components {
             limit: number;
             offset: number;
         };
+        /**
+         * @description Deterministic scorer kinds for golden-case expected signals. Case pass = all signals pass. No LLM-as-judge in v1.
+         * @enum {string}
+         */
+        EvalExpectedSignalKindDto: "contains" | "not_contains" | "regex" | "json_path_equals";
+        /**
+         * @description Model provider vocabulary aligned with AI Usage `modelName` surfaces (`cursor` | `claude`).
+         * @enum {string}
+         */
+        EvalAiProviderDto: "cursor" | "claude";
+        /** @description One expected signal on a golden case. Use `value` for `contains` / `not_contains` (substring) and for `json_path_equals` (expected value as string). Use `pattern` for `regex`. Use `path` (JSONPath) for `json_path_equals`. */
+        EvalExpectedSignalDto: {
+            id: string;
+            kind: components["schemas"]["EvalExpectedSignalKindDto"];
+            /** @description Substring for `contains` / `not_contains`, or expected value for `json_path_equals`. */
+            value?: string;
+            /** @description Regular expression source for `regex`. */
+            pattern?: string;
+            /** @description JSONPath expression for `json_path_equals`. */
+            path?: string;
+        };
+        /** @description One golden case in a suite. 1–20 cases per suite; each case requires ≥1 expected signal. When `fixtureCompletion` is set, the worker scores that text without calling a live model (CI/demo path). */
+        EvalCaseDto: {
+            id: string;
+            name: string;
+            /** @description Case input payload (opaque string; often JSON text). */
+            input: string;
+            /** @description Optional fixture completion. When present, the worker uses it instead of a live provider call. */
+            fixtureCompletion?: string;
+            expectedSignals: components["schemas"]["EvalExpectedSignalDto"][];
+        };
+        /** @description Suite target — at least one of prompt or model. Prompt path requires non-empty `promptBody` (text snapshot) and may include optional `promptKey` slug. Model path requires `provider` + `modelName` (vendor string, same vocabulary as AI Usage `modelName`). Create/update reject when both prompt body is empty and model fields are missing. No separate prompt-template registry in v1; versioning is the suite `version`. */
+        EvalSuiteTargetDto: {
+            /** @description Prompt text snapshot. Empty string allowed only when model fields are set. */
+            promptBody?: string;
+            /** @description Optional slug for the prompt (not a registry foreign key in v1). */
+            promptKey?: string | null;
+            /**
+             * @description Model provider; null when suite is prompt-only.
+             * @enum {string|null}
+             */
+            provider?: "cursor" | "claude" | null;
+            /** @description Vendor model id string (aligned with AI Usage `modelName`). */
+            modelName?: string | null;
+        };
+        /** @description Latest version of a workspace eval suite. Max 50 suites per workspace. Name 1–120 chars; description ≤ 2000; version starts at 1. */
+        EvalSuiteDto: {
+            /** Format: uuid */
+            id: string;
+            name: string;
+            description: string;
+            /** @description Monotonic suite version; bumps when target/cases/promptBody change. */
+            version: number;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+            /** Format: uuid */
+            createdByUserId: string;
+            target: components["schemas"]["EvalSuiteTargetDto"];
+            cases: components["schemas"]["EvalCaseDto"][];
+        };
+        EvalSuiteListDto: {
+            suites: components["schemas"]["EvalSuiteDto"][];
+        };
+        CreateEvalSuiteBodyDto: {
+            name: string;
+            /** @default  */
+            description: string;
+            target: components["schemas"]["EvalSuiteTargetDto"];
+            cases: components["schemas"]["EvalCaseDto"][];
+        };
+        /** @description Full replace of mutable suite fields. Version bumps only when `target`, `cases`, or `promptBody` change versus the stored latest version. */
+        UpdateEvalSuiteBodyDto: {
+            name: string;
+            /** @default  */
+            description: string;
+            target: components["schemas"]["EvalSuiteTargetDto"];
+            cases: components["schemas"]["EvalCaseDto"][];
+        };
+        /** @enum {string} */
+        EvalRunStatusDto: "queued" | "running" | "succeeded" | "failed" | "cancelled";
+        /**
+         * @description Per-case outcome. `error` is used when completion is unavailable (`code: completion_unavailable`) or another non-score failure occurs.
+         * @enum {string}
+         */
+        EvalCaseResultStatusDto: "passed" | "failed" | "error";
+        /** @description Persisted result for one case. `pass` is true only when `status` is `passed` (all expected signals matched). On signal failure, `pass` is false and `failedSignalIds` lists the failing signal ids. On `completion_unavailable`, `status` is `error` and `code` is set. */
+        EvalCaseResultDto: {
+            caseId: string;
+            name: string;
+            status: components["schemas"]["EvalCaseResultStatusDto"];
+            pass: boolean;
+            failedSignalIds: string[];
+            /** @description Completion text used for scoring (fixture or live). */
+            completion?: string | null;
+            inputTokens?: number | null;
+            outputTokens?: number | null;
+            /** @description Provider-reported cost in cents when available. */
+            costCents?: number | null;
+            /** @description Machine-readable error when `status` is `error` (e.g. `completion_unavailable`). */
+            code?: string | null;
+            /** @description Human-readable error detail when `status` is `error`. */
+            error?: string | null;
+        };
+        /** @description Immutable suite snapshot pinned on a run (`suiteVersion` + JSON). Used so historical runs stay interpretable after later suite edits. */
+        EvalSuiteSnapshotDto: {
+            name: string;
+            description: string;
+            version: number;
+            target: components["schemas"]["EvalSuiteTargetDto"];
+            cases: components["schemas"]["EvalCaseDto"][];
+        };
+        /** @description Persisted eval run. Suite score = `passedCases / scoredCases` in [0,1] when at least one case was scored; `null` when the run ends with all cases in `error` (status `failed`). List endpoints return at most the last 50 runs per suite. */
+        EvalRunDto: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            suiteId: string;
+            suiteVersion: number;
+            status: components["schemas"]["EvalRunStatusDto"];
+            /**
+             * Format: date-time
+             * @description Set when the worker claims the run (`running`).
+             */
+            startedAt: string | null;
+            /** Format: date-time */
+            finishedAt: string | null;
+            passCount: number;
+            failCount: number;
+            errorCount: number;
+            /** @description `passedCases / scoredCases` in [0,1], or null when no case was scored (all-error run). */
+            score: number | null;
+            caseResults: components["schemas"]["EvalCaseResultDto"][];
+            /** @description Pinned suite snapshot for this run (present on persisted runs). */
+            suiteSnapshot?: components["schemas"]["EvalSuiteSnapshotDto"] | null;
+        };
+        EvalRunListDto: {
+            runs: components["schemas"]["EvalRunDto"][];
+        };
+        EvalRunEnqueueResponseDto: {
+            /** Format: uuid */
+            runId: string;
+            /**
+             * @description Always `queued` on enqueue; poll GET run for progress.
+             * @enum {string}
+             */
+            status: "queued";
+        };
+        /** @description Regression when prior score − current score ≥ 0.10 on the same suiteId+suiteVersion case set, or suite score drop ≥ 0.10. */
+        EvalRegressionDto: {
+            /** Format: uuid */
+            suiteId: string;
+            suiteName?: string;
+            suiteVersion: number;
+            /** @description Set for case-level regressions; null for suite-level score drops. */
+            caseId?: string | null;
+            caseName?: string | null;
+            /** Format: uuid */
+            priorRunId?: string;
+            /** Format: uuid */
+            currentRunId?: string;
+            priorScore: number;
+            currentScore: number;
+            /** @description priorScore − currentScore (always ≥ 0.10 for listed items). */
+            scoreDrop: number;
+        };
+        /** @description Tip derived from failed signal notes / case names on recent runs. */
+        EvalPromptTipDto: {
+            /** Format: uuid */
+            suiteId: string;
+            suiteName?: string;
+            caseId?: string | null;
+            caseName?: string | null;
+            signalId?: string | null;
+            message: string;
+        };
+        /** @description Averages over successful cases in the last succeeded run per suite (workspace rollup). Nullables when token/cost fields were not returned. */
+        EvalTokenEfficiencyDto: {
+            avgInputTokens: number | null;
+            avgOutputTokens: number | null;
+            avgCostCents: number | null;
+        };
+        EvalModelComparisonDto: {
+            provider: components["schemas"]["EvalAiProviderDto"];
+            modelName: string;
+            suiteCount: number;
+            /** @description Average suite score across succeeded runs for this model; null when none. */
+            avgScore: number | null;
+        };
+        /** @description Insights hub payload for Prompt & model evals. Empty succeeded-run history → empty arrays and null `tokenEfficiency`. */
+        EvalInsightsDto: {
+            regressions: components["schemas"]["EvalRegressionDto"][];
+            promptTips: components["schemas"]["EvalPromptTipDto"][];
+            tokenEfficiency: components["schemas"]["EvalTokenEfficiencyDto"] | null;
+            modelComparison: components["schemas"]["EvalModelComparisonDto"][];
+        };
     };
     responses: {
         /** @description Missing or invalid bearer token */
@@ -11035,6 +11365,10 @@ export interface components {
     };
     parameters: {
         WorkspaceId: string;
+        /** @description Eval suite id (`tai_workspace_eval_suites.id`). */
+        EvalSuiteId: string;
+        /** @description Eval run id (`tai_workspace_eval_runs.id`). */
+        EvalRunId: string;
         RepoId: string;
         /** @description Provider repository slug in `owner/repo` form (GitHub). Used for shareable public URLs; resolves to the same row as `repoId` UUID internally. */
         ProviderSlug: string;
@@ -11684,10 +12018,33 @@ export type InsightsTestPyramidCiQualityDto = components['schemas']['InsightsTes
 export type InsightsTestPyramidSummaryDto = components['schemas']['InsightsTestPyramidSummaryDto'];
 export type InsightsTestPyramidRepoItemDto = components['schemas']['InsightsTestPyramidRepoItemDto'];
 export type InsightsTestPyramidRepoListDto = components['schemas']['InsightsTestPyramidRepoListDto'];
+export type EvalExpectedSignalKindDto = components['schemas']['EvalExpectedSignalKindDto'];
+export type EvalAiProviderDto = components['schemas']['EvalAiProviderDto'];
+export type EvalExpectedSignalDto = components['schemas']['EvalExpectedSignalDto'];
+export type EvalCaseDto = components['schemas']['EvalCaseDto'];
+export type EvalSuiteTargetDto = components['schemas']['EvalSuiteTargetDto'];
+export type EvalSuiteDto = components['schemas']['EvalSuiteDto'];
+export type EvalSuiteListDto = components['schemas']['EvalSuiteListDto'];
+export type CreateEvalSuiteBodyDto = components['schemas']['CreateEvalSuiteBodyDto'];
+export type UpdateEvalSuiteBodyDto = components['schemas']['UpdateEvalSuiteBodyDto'];
+export type EvalRunStatusDto = components['schemas']['EvalRunStatusDto'];
+export type EvalCaseResultStatusDto = components['schemas']['EvalCaseResultStatusDto'];
+export type EvalCaseResultDto = components['schemas']['EvalCaseResultDto'];
+export type EvalSuiteSnapshotDto = components['schemas']['EvalSuiteSnapshotDto'];
+export type EvalRunDto = components['schemas']['EvalRunDto'];
+export type EvalRunListDto = components['schemas']['EvalRunListDto'];
+export type EvalRunEnqueueResponseDto = components['schemas']['EvalRunEnqueueResponseDto'];
+export type EvalRegressionDto = components['schemas']['EvalRegressionDto'];
+export type EvalPromptTipDto = components['schemas']['EvalPromptTipDto'];
+export type EvalTokenEfficiencyDto = components['schemas']['EvalTokenEfficiencyDto'];
+export type EvalModelComparisonDto = components['schemas']['EvalModelComparisonDto'];
+export type EvalInsightsDto = components['schemas']['EvalInsightsDto'];
 export type ResponseUnauthorized = components['responses']['Unauthorized'];
 export type ResponseForbidden = components['responses']['Forbidden'];
 export type ResponseZenHrSyncInProgress = components['responses']['ZenHrSyncInProgress'];
 export type ParameterWorkspaceId = components['parameters']['WorkspaceId'];
+export type ParameterEvalSuiteId = components['parameters']['EvalSuiteId'];
+export type ParameterEvalRunId = components['parameters']['EvalRunId'];
 export type ParameterRepoId = components['parameters']['RepoId'];
 export type ParameterProviderSlug = components['parameters']['ProviderSlug'];
 export type ParameterProjectId = components['parameters']['ProjectId'];
@@ -12013,6 +12370,108 @@ export interface operations {
             };
         };
     };
+    runAssessmentManifestValidation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    manifest: {
+                        /** @enum {string} */
+                        offerId: "engineering_readiness_baseline" | "agentic_ai_roi";
+                        dictionaryVersion: string;
+                        /** @enum {string} */
+                        validation: "validated" | "not_validated";
+                        /** @enum {string} */
+                        shareMode: "internal" | "external";
+                        /** @enum {string|null} */
+                        watermark: "NOT VALIDATED" | "SAMPLE · SYNTHETIC DATA" | null;
+                        scope: Record<string, never>;
+                        windows: Record<string, never>;
+                        sources: Record<string, never>[];
+                        consent: Record<string, never>;
+                        sections: Record<string, never>[];
+                    };
+                    workspaceId: string;
+                    expectedWorkspaceId: string;
+                    expectedRepositoryIds: string[];
+                    soldWindowComplete: boolean;
+                    premiumAiAssessable: boolean;
+                    namedPersonSectionIds: string[];
+                    tolerances: {
+                        id: string;
+                        /** @enum {string} */
+                        status: "unset" | "exceeded" | "within";
+                    }[];
+                };
+            };
+        };
+        responses: {
+            /** @description Validation result. Client validation and watermark inputs are ignored. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        buyerDeliverable: boolean;
+                        /** @enum {string} */
+                        validation: "validated" | "not_validated";
+                        /** @enum {string|null} */
+                        watermark: "NOT VALIDATED" | null;
+                        reasons: {
+                            code: string;
+                            message: string;
+                        }[];
+                        contentHash: string;
+                    };
+                };
+            };
+            /** @description Body failed validation. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "manifest.offerId is not a known assessment offer",
+                     *       "code": "invalid_body"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description Missing or invalid JWT. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description Caller is not a platform admin. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "Forbidden",
+                     *       "code": "forbidden"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
     adminListReadinessTokenUsage: {
         parameters: {
             query?: {
@@ -24093,5 +24552,427 @@ export interface operations {
             };
         };
     };
+    listEvalSuites: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Suite list (latest version per suite) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "suites": []
+                     *     }
+                     */
+                    "application/json": components["schemas"]["EvalSuiteListDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            /** @description Workspace not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    createEvalSuite: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "name": "Greeting quality",
+                 *       "description": "Fixture-backed smoke suite for the support greeting prompt",
+                 *       "target": {
+                 *         "promptBody": "You are a support agent. Greet the user by name.",
+                 *         "promptKey": "support-greeting",
+                 *         "provider": "cursor",
+                 *         "modelName": "gpt-4.1-mini"
+                 *       },
+                 *       "cases": [
+                 *         {
+                 *           "id": "case-hello",
+                 *           "name": "Hello Alice",
+                 *           "input": "{\"name\":\"Alice\"}",
+                 *           "fixtureCompletion": "Hello Alice, how can I help you today?",
+                 *           "expectedSignals": [
+                 *             {
+                 *               "id": "sig-contains-hello",
+                 *               "kind": "contains",
+                 *               "value": "Hello Alice"
+                 *             },
+                 *             {
+                 *               "id": "sig-not-sorry",
+                 *               "kind": "not_contains",
+                 *               "value": "I cannot"
+                 *             }
+                 *           ]
+                 *         }
+                 *       ]
+                 *     }
+                 */
+                "application/json": components["schemas"]["CreateEvalSuiteBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Suite created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EvalSuiteDto"];
+                };
+            };
+            /** @description Validation failed — empty cases (`eval_suite_cases_required`), missing target (prompt and model), invalid name/description lengths, case/signal bounds, or malformed body. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Authenticated but not a workspace editor/admin */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "Workspace editor role required",
+                     *       "code": "workspace_editor_required"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description Workspace not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description Workspace already has the maximum of 50 suites */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "Maximum of 50 eval suites per workspace",
+                     *       "code": "eval_suite_limit_reached"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    getEvalSuite: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                /** @description Eval suite id (`tai_workspace_eval_suites.id`). */
+                suiteId: components["parameters"]["EvalSuiteId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Suite (latest version) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EvalSuiteDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            /** @description Workspace or suite not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    updateEvalSuite: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                /** @description Eval suite id (`tai_workspace_eval_suites.id`). */
+                suiteId: components["parameters"]["EvalSuiteId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateEvalSuiteBodyDto"];
+            };
+        };
+        responses: {
+            /** @description Suite updated (possibly with bumped version) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EvalSuiteDto"];
+                };
+            };
+            /** @description Validation failed (same codes as create) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Authenticated but not a workspace editor/admin */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "Workspace editor role required",
+                     *       "code": "workspace_editor_required"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description Workspace or suite not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    listEvalRuns: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                /** @description Eval suite id (`tai_workspace_eval_suites.id`). */
+                suiteId: components["parameters"]["EvalSuiteId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Run history (max 50) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "runs": []
+                     *     }
+                     */
+                    "application/json": components["schemas"]["EvalRunListDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            /** @description Workspace or suite not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    enqueueEvalRun: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                /** @description Eval suite id (`tai_workspace_eval_suites.id`). */
+                suiteId: components["parameters"]["EvalSuiteId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Run queued */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "runId": "22222222-2222-4222-8222-222222222222",
+                     *       "status": "queued"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["EvalRunEnqueueResponseDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Authenticated but not a workspace editor/admin */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "Workspace editor role required",
+                     *       "code": "workspace_editor_required"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description Workspace or suite not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+            /** @description An active queued or running eval already exists for this suite */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "An eval run is already in progress for this suite",
+                     *       "code": "eval_run_in_progress"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    getEvalRun: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+                /** @description Eval suite id (`tai_workspace_eval_suites.id`). */
+                suiteId: components["parameters"]["EvalSuiteId"];
+                /** @description Eval run id (`tai_workspace_eval_runs.id`). */
+                runId: components["parameters"]["EvalRunId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Run detail */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EvalRunDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            /** @description Workspace, suite, or run not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
+    getEvalInsights: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspaceId: components["parameters"]["WorkspaceId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Insights payload */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EvalInsightsDto"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            /** @description Workspace not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorMessageDto"];
+                };
+            };
+        };
+    };
 }
 //# sourceMappingURL=openapi.d.ts.map