@trainly/react 1.6.2 → 2.0.0

package/dist/api/VersionsClient.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Versions client for publishing and managing configuration versions.
+ */
+import { PublishedVersion, VersionDiff } from "../types";
+export declare class VersionsClient {
+    private baseUrl;
+    private chatId;
+    private getHeaders;
+    constructor(baseUrl: string, chatId: string, getHeaders: () => HeadersInit);
+    private request;
+    publish(version: string, description?: string): Promise<PublishedVersion>;
+    listVersions(page?: number, limit?: number): Promise<PublishedVersion[]>;
+    getVersion(versionId: string): Promise<PublishedVersion>;
+    rollback(versionId: string): Promise<boolean>;
+    compareVersions(versionA: string, versionB: string): Promise<VersionDiff>;
+    getUnpublishedChanges(): Promise<boolean>;
+    getActiveVersion(): Promise<PublishedVersion | null>;
+}

package/dist/api/VersionsClient.js

@@ -0,0 +1,160 @@
+/**
+ * Versions client for publishing and managing configuration versions.
+ */
+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 VersionsClient = /** @class */ (function () {
+    function VersionsClient(baseUrl, chatId, getHeaders) {
+        this.baseUrl = baseUrl;
+        this.chatId = chatId;
+        this.getHeaders = getHeaders;
+    }
+    VersionsClient.prototype.request = function (method, endpoint, body, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryString, url, response, error;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryString = params ? "?".concat(new URLSearchParams(params)) : "";
+                        url = "".concat(this.baseUrl, "/").concat(endpoint).concat(queryString);
+                        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()];
+                }
+            });
+        });
+    };
+    // Publishing
+    VersionsClient.prototype.publish = function (version, description) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("POST", "v1/".concat(this.chatId, "/versions/publish"), {
+                        version: version,
+                        description: description,
+                    })];
+            });
+        });
+    };
+    VersionsClient.prototype.listVersions = function () {
+        return __awaiter(this, arguments, void 0, function (page, limit) {
+            var result;
+            if (page === void 0) { page = 1; }
+            if (limit === void 0) { limit = 20; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("GET", "v1/".concat(this.chatId, "/versions"), undefined, {
+                            page: page.toString(),
+                            limit: limit.toString(),
+                        })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.versions];
+                }
+            });
+        });
+    };
+    VersionsClient.prototype.getVersion = function (versionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("GET", "v1/".concat(this.chatId, "/versions/").concat(versionId))];
+            });
+        });
+    };
+    // Rollback
+    VersionsClient.prototype.rollback = function (versionId) {
+        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, "/versions/").concat(versionId, "/rollback"))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success];
+                }
+            });
+        });
+    };
+    VersionsClient.prototype.compareVersions = function (versionA, versionB) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("GET", "v1/".concat(this.chatId, "/versions/compare"), undefined, {
+                        version_a: versionA,
+                        version_b: versionB,
+                    })];
+            });
+        });
+    };
+    // Status
+    VersionsClient.prototype.getUnpublishedChanges = 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, "/versions/unpublished-changes"))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.has_changes];
+                }
+            });
+        });
+    };
+    VersionsClient.prototype.getActiveVersion = 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, "/versions/active"))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.version || null];
+                }
+            });
+        });
+    };
+    return VersionsClient;
+}());
+export { VersionsClient };

package/dist/index.d.ts

@@ -1,8 +1,13 @@
 export { TrainlyProvider } from "./TrainlyProvider";
 export { useTrainly } from "./useTrainly";
 export { TrainlyClient } from "./api/TrainlyClient";
+export { TestingClient } from "./api/TestingClient";
+export { FineTuningClient } from "./api/FineTuningClient";
+export { ConfigClient } from "./api/ConfigClient";
+export { AnalyticsClient } from "./api/AnalyticsClient";
+export { VersionsClient } from "./api/VersionsClient";
 export { TrainlyChat } from "./components/TrainlyChat";
 export { TrainlyUpload } from "./components/TrainlyUpload";
 export { TrainlyStatus } from "./components/TrainlyStatus";
 export { TrainlyFileManager } from "./components/TrainlyFileManager";
-export type { TrainlyProviderProps, TrainlyConfig, ChatMessage, Citation, UploadResult, TextContent, BulkUploadResult, BulkUploadFileResult, FileInfo, FileListResult, FileDeleteResult, TrainlyError, TrainlyFileManagerProps, } from "./types";
+export type { TrainlyProviderProps, TrainlyConfig, ChatMessage, Citation, UploadResult, TextContent, BulkUploadResult, BulkUploadFileResult, FileInfo, FileListResult, FileDeleteResult, TrainlyError, TrainlyFileManagerProps, TestSuite, TestCase, TestRun, TestRunResults, TestResult, TestAnalytics, TestAssertion, PaginatedSuites, PreferencePair, TrainingJob, PaginatedPairs, BatchResult, ValidationResults, ChatSettings, RagConfig, ChunkingConfig, RetrievalConfig, RerankingConfig, ValidationPolicy, RepairLoopConfig, QueryTrace, QueryTraceDetails, TokenUsage, TimingBreakdown, ChunkInfo, MetricsSummary, CostBreakdown, PerformanceStats, PublishedVersion, VersionDiff, FileSnapshot, } from "./types";

package/dist/index.js

@@ -3,6 +3,12 @@ export { TrainlyProvider } from "./TrainlyProvider";
 export { useTrainly } from "./useTrainly";
 // Core client (for non-React usage)
 export { TrainlyClient } from "./api/TrainlyClient";
+// Feature sub-clients (for direct usage)
+export { TestingClient } from "./api/TestingClient";
+export { FineTuningClient } from "./api/FineTuningClient";
+export { ConfigClient } from "./api/ConfigClient";
+export { AnalyticsClient } from "./api/AnalyticsClient";
+export { VersionsClient } from "./api/VersionsClient";
 // Pre-built components
 export { TrainlyChat } from "./components/TrainlyChat";
 export { TrainlyUpload } from "./components/TrainlyUpload";

package/dist/types.d.ts

@@ -100,6 +100,10 @@ export interface TrainlyContextValue {
         answer: string;
         citations?: Citation[];
     }>;
+    askStream: (question: string, options?: {
+        scope_filters?: Record<string, string | number | boolean>;
+        onChunk?: (chunk: string) => void;
+    }) => AsyncGenerator<string, void, unknown>;
     askWithCitations: (question: string) => Promise<{
         answer: string;
         citations: Citation[];
@@ -110,6 +114,22 @@ export interface TrainlyContextValue {
     deleteFile: (fileId: string) => Promise<FileDeleteResult>;
     bulkUploadFiles: (files: File[], scopeValues?: Record<string, string | number | boolean>) => Promise<BulkUploadResult>;
     bulkUploadText: (textContents: TextContent[], scopeValues?: Record<string, string | number | boolean>) => Promise<BulkUploadResult>;
+    getChatSettings: () => Promise<{
+        success: boolean;
+        chat_id?: string;
+        settings?: any;
+    }>;
+    updateChatSettings: (settings: {
+        custom_prompt?: string;
+        temperature?: number;
+        max_tokens?: number;
+        selected_model?: string;
+    }) => Promise<{
+        success: boolean;
+        chat_id?: string;
+        updated?: any;
+        message?: string;
+    }>;
     connectWithOAuthToken: (idToken: string) => Promise<void>;
     isLoading: boolean;
     isConnected: boolean;
@@ -120,3 +140,261 @@ export interface TrainlyContextValue {
     sendMessage: (content: string) => Promise<void>;
     clearMessages: () => void;
 }
+export interface TestAssertion {
+    type: "contains" | "exact" | "regex" | "semantic" | "negative";
+    value: string;
+    match_threshold?: number;
+}
+export interface TestResult {
+    case_id: string;
+    case_name: string;
+    passed: boolean;
+    actual_answer: string;
+    expected_answer: string;
+    failure_reason?: string;
+    execution_time_ms?: number;
+    assertions_passed?: number;
+    assertions_failed?: number;
+}
+export interface TestCase {
+    case_id: string;
+    name: string;
+    query: string;
+    expected_answer: string;
+    category: "golden" | "contradiction" | "multi_hop" | "numerical" | "negation" | "distractor" | "adversarial" | "paraphrase";
+    suite_id?: string;
+    expected_decision?: "ANSWER" | "NEEDS_INFO" | "REFUSE";
+    assertions?: TestAssertion[];
+    expected_source_file?: string;
+    last_result?: TestResult;
+    created_at?: string;
+}
+export interface TestSuite {
+    suite_id: string;
+    name: string;
+    description?: string;
+    test_count: number;
+    pass_rate?: number;
+    last_run_at?: string;
+    last_run_status?: "passed" | "failed" | "partial" | "running";
+    tags?: string[];
+    created_at?: string;
+}
+export interface PaginatedSuites {
+    suites: TestSuite[];
+    total: number;
+    page: number;
+    limit: number;
+    has_more: boolean;
+}
+export interface TestRun {
+    run_id: string;
+    suite_id: string;
+    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    started_at?: string;
+    completed_at?: string;
+}
+export interface TestRunResults {
+    run_id: string;
+    suite_id: string;
+    status: "running" | "completed" | "failed" | "cancelled";
+    passed: number;
+    failed: number;
+    total: number;
+    pass_rate: number;
+    started_at: string;
+    completed_at?: string;
+    duration_ms?: number;
+    results: TestResult[];
+}
+export interface TestAnalytics {
+    suite_id: string;
+    total_runs: number;
+    average_pass_rate: number;
+    average_duration_ms: number;
+    total_tests: number;
+    pass_trend?: number[];
+}
+export interface ValidationResults {
+    preferred_passed: boolean;
+    non_preferred_passed: boolean;
+    validators_failed?: string[];
+}
+export interface PreferencePair {
+    pair_id: string;
+    input_messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    preferred_output: string;
+    non_preferred_output: string;
+    status: "draft" | "approved" | "rejected" | "used_in_training";
+    source: "manual" | "ai_generated" | "from_test_run" | "from_query_logs";
+    validation_results?: ValidationResults;
+    notes?: string;
+    created_at?: string;
+}
+export interface PaginatedPairs {
+    pairs: PreferencePair[];
+    total: number;
+    page: number;
+    limit: number;
+    has_more: boolean;
+}
+export interface BatchResult {
+    success: boolean;
+    total: number;
+    successful: number;
+    failed: number;
+    errors?: string[];
+}
+export interface TrainingJob {
+    job_id: string;
+    openai_job_id?: string;
+    base_model: string;
+    fine_tuned_model_id?: string;
+    status: "preparing" | "uploading" | "queued" | "running" | "succeeded" | "failed" | "cancelled";
+    num_pairs: number;
+    progress?: number;
+    started_at?: string;
+    completed_at?: string;
+    error?: string;
+    suffix?: string;
+    beta: number;
+}
+export interface ChunkingConfig {
+    strategy: "auto" | "fixed_size" | "semantic" | "sentence" | "paragraph" | "code" | "custom";
+    chunk_size?: number;
+    chunk_overlap?: number;
+    max_chunk_size?: number;
+}
+export interface RetrievalConfig {
+    mode: "hybrid" | "vector" | "keyword";
+    vector_weight?: number;
+    keyword_weight?: number;
+    top_k: number;
+    similarity_threshold: number;
+}
+export interface RerankingConfig {
+    enabled: boolean;
+    model: "cohere" | "cross_encoder" | "none";
+    top_n?: number;
+}
+export interface RagConfig {
+    chunking: ChunkingConfig;
+    retrieval: RetrievalConfig;
+    reranking: RerankingConfig;
+}
+export interface ValidationPolicy {
+    forbidden_phrases?: string[];
+    required_phrases?: string[];
+    pii_detection_enabled: boolean;
+    banned_packages?: string[];
+    required_packages?: string[];
+    require_error_handling: boolean;
+    max_response_length?: number;
+    require_citations: boolean;
+}
+export interface RepairLoopConfig {
+    enabled: boolean;
+    max_retries: number;
+}
+export interface ChatSettings {
+    chat_id: string;
+    model?: string;
+    temperature?: number;
+    max_tokens?: number;
+    custom_prompt?: string;
+    repair_loop?: RepairLoopConfig;
+    rag_config?: RagConfig;
+    validation_policy?: ValidationPolicy;
+}
+export interface TokenUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface TimingBreakdown {
+    preprocessing_time: number;
+    embedding_time: number;
+    retrieval_time: number;
+    reranking_time: number;
+    context_assembly_time: number;
+    prompt_construction_time: number;
+    llm_time: number;
+    postprocessing_time: number;
+    total_time: number;
+}
+export interface ChunkInfo {
+    chunk_id: string;
+    score: number;
+    source_file: string;
+    chunk_text: string;
+    rank_before_rerank?: number;
+    rank_after_rerank?: number;
+}
+export interface QueryTrace {
+    trace_id: string;
+    query: string;
+    response: string;
+    status: "success" | "error";
+    total_time_ms: number;
+    tokens: TokenUsage;
+    cost: number;
+    timestamp: string;
+}
+export interface QueryTraceDetails extends QueryTrace {
+    timing: TimingBreakdown;
+    chunks: ChunkInfo[];
+    full_prompt?: string;
+}
+export interface MetricsSummary {
+    total_queries: number;
+    successful_queries: number;
+    failed_queries: number;
+    average_response_time_ms: number;
+    total_cost: number;
+    average_cost_per_query: number;
+    date_range_start: string;
+    date_range_end: string;
+}
+export interface CostBreakdown {
+    total_cost: number;
+    embedding_cost: number;
+    llm_cost: number;
+    reranking_cost: number;
+    date_range_start: string;
+    date_range_end: string;
+}
+export interface PerformanceStats {
+    p50_response_time_ms: number;
+    p95_response_time_ms: number;
+    p99_response_time_ms: number;
+    average_chunks_retrieved: number;
+    average_tokens_per_query: number;
+}
+export interface FileSnapshot {
+    file_id: string;
+    filename: string;
+    size_bytes: number;
+    chunk_count: number;
+}
+export interface PublishedVersion {
+    version_id: string;
+    version: string;
+    status: "active" | "superseded" | "corrupted";
+    description?: string;
+    settings_snapshot?: Record<string, any>;
+    file_snapshots?: FileSnapshot[];
+    total_files: number;
+    published_at?: string;
+    published_by?: string;
+}
+export interface VersionDiff {
+    version_a: string;
+    version_b: string;
+    settings_changed: string[];
+    files_added: string[];
+    files_removed: string[];
+    files_modified: string[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainly/react",
-  "version": "1.6.2",
+  "version": "2.0.0",
   "description": "Dead simple RAG integration for React apps with OAuth authentication and custom scopes",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",