@trainly/react 1.6.3 → 2.0.0

package/dist/api/FineTuningClient.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Fine-tuning client for managing DPO preference pairs and training jobs.
+ */
+import { PreferencePair, TrainingJob, PaginatedPairs, BatchResult } from "../types";
+export declare class FineTuningClient {
+    private baseUrl;
+    private chatId;
+    private getHeaders;
+    constructor(baseUrl: string, chatId: string, getHeaders: () => HeadersInit);
+    private request;
+    createPreferencePair(params: {
+        input_messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        preferred_output: string;
+        non_preferred_output: string;
+        source?: string;
+        notes?: string;
+    }): Promise<PreferencePair>;
+    batchCreatePairs(pairs: Array<{
+        input_messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        preferred_output: string;
+        non_preferred_output: string;
+        source?: string;
+        notes?: string;
+    }>): Promise<BatchResult>;
+    updatePair(pairId: string, updates: {
+        preferred_output?: string;
+        non_preferred_output?: string;
+        status?: string;
+        notes?: string;
+    }): Promise<PreferencePair>;
+    deletePair(pairId: string): Promise<boolean>;
+    listPairs(params?: {
+        status?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedPairs>;
+    approvePairs(pairIds: string[]): Promise<BatchResult>;
+    rejectPairs(pairIds: string[]): Promise<BatchResult>;
+    generatePairsFromTestRun(runId: string, onlyFailed?: boolean, synthesizeGood?: boolean): Promise<PreferencePair[]>;
+    startTrainingJob(params?: {
+        base_model?: string;
+        suffix?: string;
+        beta?: number;
+        min_approved_pairs?: number;
+    }): Promise<TrainingJob>;
+    getJobStatus(jobId: string): Promise<TrainingJob>;
+    listJobs(status?: string): Promise<TrainingJob[]>;
+    cancelJob(jobId: string): Promise<boolean>;
+    waitForJob(jobId: string, timeout?: number, pollInterval?: number): Promise<TrainingJob>;
+    activateModel(modelId: string): Promise<boolean>;
+    deactivateFineTunedModel(): Promise<boolean>;
+    getActiveModel(): Promise<string | null>;
+}

package/dist/api/FineTuningClient.js

@@ -0,0 +1,279 @@
+/**
+ * Fine-tuning client for managing DPO preference pairs and training jobs.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var FineTuningClient = /** @class */ (function () {
+    function FineTuningClient(baseUrl, chatId, getHeaders) {
+        this.baseUrl = baseUrl;
+        this.chatId = chatId;
+        this.getHeaders = getHeaders;
+    }
+    FineTuningClient.prototype.request = function (method, endpoint, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, error;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "".concat(this.baseUrl, "/").concat(endpoint);
+                        return [4 /*yield*/, fetch(url, {
+                                method: method,
+                                headers: this.getHeaders(),
+                                body: body ? JSON.stringify(body) : undefined,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        if (!!response.ok) return [3 /*break*/, 3];
+                        return [4 /*yield*/, response.json().catch(function () { return ({ detail: response.statusText }); })];
+                    case 2:
+                        error = _a.sent();
+                        throw new Error(error.detail || "HTTP ".concat(response.status));
+                    case 3: return [2 /*return*/, response.json()];
+                }
+            });
+        });
+    };
+    // Preference Pair Management
+    FineTuningClient.prototype.createPreferencePair = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/pairs"), __assign(__assign({}, params), { source: params.source || "manual" }))];
+            });
+        });
+    };
+    FineTuningClient.prototype.batchCreatePairs = function (pairs) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/pairs/batch"), { pairs: pairs })];
+            });
+        });
+    };
+    FineTuningClient.prototype.updatePair = function (pairId, updates) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("PUT", "v1/".concat(this.chatId, "/fine-tuning/pairs/").concat(pairId), updates)];
+            });
+        });
+    };
+    FineTuningClient.prototype.deletePair = function (pairId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("DELETE", "v1/".concat(this.chatId, "/fine-tuning/pairs/").concat(pairId))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    FineTuningClient.prototype.listPairs = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var searchParams;
+            return __generator(this, function (_a) {
+                searchParams = new URLSearchParams(__assign({ page: ((params === null || params === void 0 ? void 0 : params.page) || 1).toString(), limit: ((params === null || params === void 0 ? void 0 : params.limit) || 50).toString() }, ((params === null || params === void 0 ? void 0 : params.status) && { status: params.status })));
+                return [2 /*return*/, this.request("GET", "v1/".concat(this.chatId, "/fine-tuning/pairs?").concat(searchParams))];
+            });
+        });
+    };
+    FineTuningClient.prototype.approvePairs = function (pairIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/pairs/bulk-approve"), {
+                        pair_ids: pairIds,
+                    })];
+            });
+        });
+    };
+    FineTuningClient.prototype.rejectPairs = function (pairIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/pairs/bulk-reject"), {
+                        pair_ids: pairIds,
+                    })];
+            });
+        });
+    };
+    // Generate Training Data from Tests
+    FineTuningClient.prototype.generatePairsFromTestRun = function (runId_1) {
+        return __awaiter(this, arguments, void 0, function (runId, onlyFailed, synthesizeGood) {
+            var result;
+            if (onlyFailed === void 0) { onlyFailed = true; }
+            if (synthesizeGood === void 0) { synthesizeGood = true; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/pairs/generate-from-test-run"), { run_id: runId, only_failed: onlyFailed, synthesize_good: synthesizeGood })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.pairs];
+                }
+            });
+        });
+    };
+    // Training Job Management
+    FineTuningClient.prototype.startTrainingJob = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/jobs"), {
+                        base_model: (params === null || params === void 0 ? void 0 : params.base_model) || "gpt-4o-mini",
+                        suffix: params === null || params === void 0 ? void 0 : params.suffix,
+                        beta: (params === null || params === void 0 ? void 0 : params.beta) || 0.1,
+                        min_approved_pairs: (params === null || params === void 0 ? void 0 : params.min_approved_pairs) || 10,
+                    })];
+            });
+        });
+    };
+    FineTuningClient.prototype.getJobStatus = function (jobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("GET", "v1/".concat(this.chatId, "/fine-tuning/jobs/").concat(jobId))];
+            });
+        });
+    };
+    FineTuningClient.prototype.listJobs = function (status) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        params = status ? "?status=".concat(status) : "";
+                        return [4 /*yield*/, this.request("GET", "v1/".concat(this.chatId, "/fine-tuning/jobs").concat(params))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.jobs];
+                }
+            });
+        });
+    };
+    FineTuningClient.prototype.cancelJob = function (jobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/jobs/").concat(jobId, "/cancel"))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    FineTuningClient.prototype.waitForJob = function (jobId_1) {
+        return __awaiter(this, arguments, void 0, function (jobId, timeout, pollInterval) {
+            var startTime, job;
+            if (timeout === void 0) { timeout = 3600000; }
+            if (pollInterval === void 0) { pollInterval = 30000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        if (!(Date.now() - startTime < timeout)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.getJobStatus(jobId)];
+                    case 2:
+                        job = _a.sent();
+                        if (["succeeded", "failed", "cancelled"].includes(job.status)) {
+                            if (job.status === "failed") {
+                                throw new Error("Training job failed: ".concat(job.error || "Unknown error"));
+                            }
+                            return [2 /*return*/, job];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, pollInterval); })];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 4: throw new Error("Training job ".concat(jobId, " did not complete within ").concat(timeout, "ms"));
+                }
+            });
+        });
+    };
+    // Model Management
+    FineTuningClient.prototype.activateModel = function (modelId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/activate-model"), { model_id: modelId })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    FineTuningClient.prototype.deactivateFineTunedModel = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("POST", "v1/".concat(this.chatId, "/fine-tuning/deactivate-model"))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    FineTuningClient.prototype.getActiveModel = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("GET", "v1/".concat(this.chatId, "/fine-tuning/active-model"))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.model_id || null];
+                }
+            });
+        });
+    };
+    return FineTuningClient;
+}());
+export { FineTuningClient };

package/dist/api/TestingClient.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Testing client for managing test suites, test cases, and test execution.
+ */
+import { TestSuite, TestCase, TestRun, TestRunResults, TestAnalytics, PaginatedSuites, TestAssertion } from "../types";
+export declare class TestingClient {
+    private baseUrl;
+    private chatId;
+    private getHeaders;
+    constructor(baseUrl: string, chatId: string, getHeaders: () => HeadersInit);
+    private request;
+    createSuite(name: string, description?: string, tags?: string[]): Promise<TestSuite>;
+    updateSuite(suiteId: string, updates: {
+        name?: string;
+        description?: string;
+        tags?: string[];
+    }): Promise<TestSuite>;
+    deleteSuite(suiteId: string): Promise<boolean>;
+    listSuites(page?: number, limit?: number, status?: string): Promise<PaginatedSuites>;
+    getSuite(suiteId: string): Promise<TestSuite>;
+    createTestCase(params: {
+        suiteId?: string;
+        name: string;
+        query: string;
+        expected_answer: string;
+        category?: string;
+        expected_decision?: string;
+        assertions?: TestAssertion[];
+        expected_source_file?: string;
+    }): Promise<TestCase>;
+    generateTestCases(countPerCategory?: number, scopeFilters?: Record<string, any>): Promise<TestCase[]>;
+    updateTestCase(caseId: string, updates: {
+        name?: string;
+        query?: string;
+        expected_answer?: string;
+        category?: string;
+        suite_id?: string;
+    }): Promise<TestCase>;
+    deleteTestCase(caseId: string): Promise<boolean>;
+    listTestCases(params?: {
+        suiteId?: string;
+        category?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<TestCase[]>;
+    runSuite(suiteId: string, parallel?: boolean, stopOnFailure?: boolean): Promise<TestRun>;
+    getRunResults(runId: string): Promise<TestRunResults>;
+    getRunHistory(suiteId: string, limit?: number): Promise<TestRun[]>;
+    cancelRun(runId: string): Promise<boolean>;
+    waitForRun(runId: string, timeout?: number, pollInterval?: number): Promise<TestRunResults>;
+    getSuiteAnalytics(suiteId: string): Promise<TestAnalytics>;
+}

package/dist/api/TestingClient.js

@@ -0,0 +1,274 @@
+/**
+ * Testing client for managing test suites, test cases, and test execution.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var TestingClient = /** @class */ (function () {
+    function TestingClient(baseUrl, chatId, getHeaders) {
+        this.baseUrl = baseUrl;
+        this.chatId = chatId;
+        this.getHeaders = getHeaders;
+    }
+    TestingClient.prototype.request = function (method, endpoint, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, error;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "".concat(this.baseUrl, "/").concat(endpoint);
+                        return [4 /*yield*/, fetch(url, {
+                                method: method,
+                                headers: this.getHeaders(),
+                                body: body ? JSON.stringify(body) : undefined,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        if (!!response.ok) return [3 /*break*/, 3];
+                        return [4 /*yield*/, response.json().catch(function () { return ({ detail: response.statusText }); })];
+                    case 2:
+                        error = _a.sent();
+                        throw new Error(error.detail || "HTTP ".concat(response.status));
+                    case 3: return [2 /*return*/, response.json()];
+                }
+            });
+        });
+    };
+    // Suite Management
+    TestingClient.prototype.createSuite = function (name, description, tags) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/testing/suites"), {
+                        name: name,
+                        description: description,
+                        tags: tags,
+                    })];
+            });
+        });
+    };
+    TestingClient.prototype.updateSuite = function (suiteId, updates) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("PUT", "v1/".concat(this.chatId, "/testing/suites/").concat(suiteId), updates)];
+            });
+        });
+    };
+    TestingClient.prototype.deleteSuite = function (suiteId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("DELETE", "v1/".concat(this.chatId, "/testing/suites/").concat(suiteId))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    TestingClient.prototype.listSuites = function () {
+        return __awaiter(this, arguments, void 0, function (page, limit, status) {
+            var params;
+            if (page === void 0) { page = 1; }
+            if (limit === void 0) { limit = 20; }
+            return __generator(this, function (_a) {
+                params = new URLSearchParams(__assign({ page: page.toString(), limit: limit.toString() }, (status && { status: status })));
+                return [2 /*return*/, this.request("GET", "v1/".concat(this.chatId, "/testing/suites?").concat(params))];
+            });
+        });
+    };
+    TestingClient.prototype.getSuite = function (suiteId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("GET", "v1/".concat(this.chatId, "/testing/suites/").concat(suiteId))];
+            });
+        });
+    };
+    // Test Case Management
+    TestingClient.prototype.createTestCase = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/testing/cases"), params)];
+            });
+        });
+    };
+    TestingClient.prototype.generateTestCases = function () {
+        return __awaiter(this, arguments, void 0, function (countPerCategory, scopeFilters) {
+            var result;
+            if (countPerCategory === void 0) { countPerCategory = 3; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("POST", "v1/".concat(this.chatId, "/testing/cases/generate"), { count_per_category: countPerCategory, scope_filters: scopeFilters })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.cases];
+                }
+            });
+        });
+    };
+    TestingClient.prototype.updateTestCase = function (caseId, updates) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("PUT", "v1/".concat(this.chatId, "/testing/cases/").concat(caseId), updates)];
+            });
+        });
+    };
+    TestingClient.prototype.deleteTestCase = function (caseId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("DELETE", "v1/".concat(this.chatId, "/testing/cases/").concat(caseId))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    TestingClient.prototype.listTestCases = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var searchParams, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        searchParams = new URLSearchParams(__assign(__assign({ page: ((params === null || params === void 0 ? void 0 : params.page) || 1).toString(), limit: ((params === null || params === void 0 ? void 0 : params.limit) || 50).toString() }, ((params === null || params === void 0 ? void 0 : params.suiteId) && { suite_id: params.suiteId })), ((params === null || params === void 0 ? void 0 : params.category) && { category: params.category })));
+                        return [4 /*yield*/, this.request("GET", "v1/".concat(this.chatId, "/testing/cases?").concat(searchParams))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.cases];
+                }
+            });
+        });
+    };
+    // Test Execution
+    TestingClient.prototype.runSuite = function (suiteId_1) {
+        return __awaiter(this, arguments, void 0, function (suiteId, parallel, stopOnFailure) {
+            if (parallel === void 0) { parallel = true; }
+            if (stopOnFailure === void 0) { stopOnFailure = false; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/testing/suites/").concat(suiteId, "/run"), {
+                        parallel: parallel,
+                        stop_on_failure: stopOnFailure,
+                    })];
+            });
+        });
+    };
+    TestingClient.prototype.getRunResults = function (runId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("GET", "v1/".concat(this.chatId, "/testing/runs/").concat(runId, "/results"))];
+            });
+        });
+    };
+    TestingClient.prototype.getRunHistory = function (suiteId_1) {
+        return __awaiter(this, arguments, void 0, function (suiteId, limit) {
+            var params, result;
+            if (limit === void 0) { limit = 10; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        params = new URLSearchParams({ limit: limit.toString() });
+                        return [4 /*yield*/, this.request("GET", "v1/".concat(this.chatId, "/testing/suites/").concat(suiteId, "/runs?").concat(params))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.runs];
+                }
+            });
+        });
+    };
+    TestingClient.prototype.cancelRun = function (runId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("POST", "v1/".concat(this.chatId, "/testing/runs/").concat(runId, "/cancel"))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    TestingClient.prototype.waitForRun = function (runId_1) {
+        return __awaiter(this, arguments, void 0, function (runId, timeout, pollInterval) {
+            var startTime, results;
+            if (timeout === void 0) { timeout = 300000; }
+            if (pollInterval === void 0) { pollInterval = 5000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        if (!(Date.now() - startTime < timeout)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.getRunResults(runId)];
+                    case 2:
+                        results = _a.sent();
+                        if (["completed", "failed", "cancelled"].includes(results.status)) {
+                            return [2 /*return*/, results];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, pollInterval); })];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 4: throw new Error("Test run ".concat(runId, " did not complete within ").concat(timeout, "ms"));
+                }
+            });
+        });
+    };
+    // Analytics
+    TestingClient.prototype.getSuiteAnalytics = function (suiteId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("GET", "v1/".concat(this.chatId, "/testing/suites/").concat(suiteId, "/analytics"))];
+            });
+        });
+    };
+    return TestingClient;
+}());
+export { TestingClient };