langtrain 0.1.11 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langtrain",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Unified JavaScript SDK for Langtrain Ecosystem",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/cli.ts

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
-import { intro, outro, select, text, spinner, isCancel, cancel, password } from '@clack/prompts';
+import {
+    intro, outro, text, select, confirm, spinner, isCancel, note, cancel, password
+} from '@clack/prompts';
 import { bgCyan, black, red, green, yellow, gray } from 'kleur/colors';
 import { Command } from 'commander';
-import { Langvision, Langtune, AgentClient, Agent, AgentCreate } from './index';
+import { AgentClient, AgentCreate, FileClient, TrainingClient, SubscriptionClient, Langvision, Langtune } from './index';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
@@ -64,6 +66,7 @@ async function main() {
         // Operation Handlers Map (O(1) lookup)
         const handlers: Record<string, (clients?: any) => Promise<void>> = {
             'login': handleLogin,
+            'status': handleSubscriptionStatus,
             'tune-finetune': (c) => handleTuneFinetune(c.tune),
             'tune-generate': (c) => handleTuneGenerate(c.tune),
             'vision-finetune': (c) => handleVisionFinetune(c.vision),
@@ -144,12 +147,39 @@ async function handleLogin() {
     intro(green('API Key updated successfully!'));
 }
 
+async function handleSubscriptionStatus() {
+    const config = getConfig();
+    if (!config.apiKey) {
+        intro(red('Not logged in. Run "login" first.'));
+        return;
+    }
+    const client = new SubscriptionClient({ apiKey: config.apiKey });
+    const s = spinner();
+    s.start('Fetching subscription status...');
+    try {
+        const info = await client.getStatus();
+        s.stop(green('Subscription Status:'));
+
+        console.log(gray('Plan: ') + (info.plan === 'pro' ? bgCyan(' PRO ') : info.plan.toUpperCase()));
+        console.log(gray('Active: ') + (info.is_active ? green('Yes') : red('No')));
+        if (info.expires_at) console.log(gray('Expires: ') + new Date(info.expires_at).toLocaleDateString());
+
+        console.log(gray('\nLimits:'));
+        console.log(`  Models: ${info.limits.max_models === -1 ? 'Unlimited' : info.limits.max_models}`);
+        console.log(`  Training Jobs: ${info.limits.max_training_jobs}`);
+
+    } catch (e: any) {
+        s.stop(red('Failed to fetch status.'));
+        console.error(e.message);
+    }
+}
+
 async function handleAgentCreate(client: AgentClient) {
     const name = await text({
         message: 'Agent Name:',
         placeholder: 'e.g. Support Bot',
         validate(value) {
-            if (value.length === 0) return 'Name is required!';
+            if (!value || value.length === 0) return 'API Key is required';
         },
     });
     if (isCancel(name)) return;
@@ -202,7 +232,7 @@ async function handleAgentCreate(client: AgentClient) {
             const wid = await text({
                 message: 'Enter Workspace ID (UUID):',
                 validate(value) {
-                    if (value.length === 0) return 'Required';
+                    if (!value || value.length === 0) return 'Required';
                 },
             });
             if (isCancel(wid)) return;
@@ -353,10 +383,60 @@ async function handleTuneFinetune(tune: Langtune) {
     });
     if (isCancel(epochs)) cancel('Operation cancelled.');
 
+    const track = await select({
+        message: 'Track this job on Langtrain Cloud?',
+        options: [
+            { value: 'yes', label: 'Yes', hint: 'Upload dataset and log job' },
+            { value: 'no', label: 'No', hint: 'Local only' }
+        ]
+    });
+    if (isCancel(track)) cancel('Operation cancelled.');
+
+    if (track === 'yes') {
+        const s = spinner();
+        s.start('Connecting to Cloud...');
+        try {
+            const config = getConfig();
+            if (!config.apiKey) throw new Error('API Key required. Run "login" first.');
+
+            // Check Subscription
+            const subClient = new SubscriptionClient({ apiKey: config.apiKey });
+            const sub = await subClient.getStatus();
+            if (!sub.features.includes('cloud_finetuning')) {
+                s.stop(red('Feature "cloud_finetuning" is not available on your plan.'));
+                const upgrade = await confirm({ message: 'Upgrade to Pro for cloud tracking?' });
+                if (upgrade && !isCancel(upgrade)) {
+                    console.log(bgCyan(black(' Visit https://langtrain.ai/dashboard/billing to upgrade. ')));
+                }
+                return;
+            }
+
+            const fileClient = new FileClient({ apiKey: config.apiKey });
+            const trainingClient = new TrainingClient({ apiKey: config.apiKey });
+
+            s.message('Uploading dataset...');
+            const fileResp = await fileClient.upload(trainFile as string);
+
+            s.message('Creating Job...');
+            const job = await trainingClient.createJob({
+                name: `cli-sft-${Date.now()}`,
+                base_model: model as string,
+                dataset_id: fileResp.id,
+                task: 'text',
+                hyperparameters: {
+                    n_epochs: parseInt(epochs as string)
+                }
+            });
+            s.stop(green(`Job tracked: ${job.id}`));
+        } catch (e: any) {
+            s.stop(red(`Tracking failed: ${e.message}`));
+            const cont = await confirm({ message: 'Continue with local training anyway?' });
+            if (!cont || isCancel(cont)) return;
+        }
+    }
+
     const s = spinner();
-    s.start('Connecting to Langtrain Cloud...');
-    await new Promise(r => setTimeout(r, 800)); // Simulatoin
-    s.message('Starting fine-tuning job...');
+    s.start('Starting local fine-tuning...');
 
     try {
         // Check if FinetuneConfig types match what's needed. 
@@ -430,6 +510,60 @@ async function handleVisionFinetune(vision: Langvision) {
         placeholder: '3',
         initialValue: '3'
     });
+    if (isCancel(epochs)) cancel('Operation cancelled');
+
+    const track = await select({
+        message: 'Track this job on Langtrain Cloud?',
+        options: [
+            { value: 'yes', label: 'Yes', hint: 'Upload dataset and log job' },
+            { value: 'no', label: 'No', hint: 'Local only' }
+        ]
+    });
+    if (isCancel(track)) cancel('Operation cancelled');
+
+    if (track === 'yes') {
+        const s = spinner();
+        s.start('Connecting to Cloud...');
+        try {
+            const config = getConfig();
+            if (!config.apiKey) throw new Error('API Key required. Run "login" first.');
+
+            // Check Subscription
+            const subClient = new SubscriptionClient({ apiKey: config.apiKey });
+            const sub = await subClient.getStatus();
+            if (!sub.features.includes('cloud_finetuning')) {
+                s.stop(red('Feature "cloud_finetuning" is not available on your plan.'));
+                const upgrade = await confirm({ message: 'Upgrade to Pro for cloud tracking?' });
+                if (upgrade && !isCancel(upgrade)) {
+                    console.log(bgCyan(black(' Visit https://langtrain.ai/dashboard/billing to upgrade. ')));
+                }
+                return;
+            }
+
+            const fileClient = new FileClient({ apiKey: config.apiKey });
+            const trainingClient = new TrainingClient({ apiKey: config.apiKey });
+
+            s.message('Uploading dataset...');
+            const fileResp = await fileClient.upload(dataset as string, undefined, 'fine-tune-vision');
+
+            s.message('Creating Job...');
+            const job = await trainingClient.createJob({
+                name: `cli-vision-${Date.now()}`,
+                base_model: model as string,
+                dataset_id: fileResp.id,
+                task: 'vision',
+                training_method: 'lora',
+                hyperparameters: {
+                    n_epochs: parseInt(epochs as string)
+                }
+            });
+            s.stop(green(`Job tracked: ${job.id}`));
+        } catch (e: any) {
+            s.stop(red(`Tracking failed: ${e.message}`));
+            const cont = await confirm({ message: 'Continue with local training anyway?' });
+            if (!cont || isCancel(cont)) return;
+        }
+    }
 
     const s = spinner();
     s.start('Analyzing dataset structure...');

package/src/files.ts

@@ -0,0 +1,53 @@
+export class FileClient {
+    private client: any; // AxiosInstance
+
+    constructor(config: { apiKey: string, baseUrl?: string }) {
+        const axios = require('axios');
+        this.client = axios.create({
+            baseURL: config.baseUrl || 'https://api.langtrain.ai/api/v1',
+            headers: {
+                'X-API-Key': config.apiKey,
+            }
+        });
+    }
+
+    async upload(file: any, workspaceId?: string, purpose: string = 'fine-tune'): Promise<FileResponse> {
+        const FormData = require('form-data');
+        const fs = require('fs');
+
+        const form = new FormData();
+        // Check if file is a path or buffer. Assuming path for CLI
+        if (typeof file === 'string') {
+            if (!fs.existsSync(file)) throw new Error(`File not found: ${file}`);
+            form.append('file', fs.createReadStream(file));
+        } else {
+            // Handle buffer or other types if needed, but for now strict to path
+            throw new Error('File path required');
+        }
+
+        if (workspaceId) form.append('workspace_id', workspaceId);
+        form.append('purpose', purpose);
+
+        const response = await this.client.post('/files', form, {
+            headers: {
+                ...form.getHeaders()
+            }
+        });
+        return response.data;
+    }
+
+    async list(workspaceId: string, purpose?: string): Promise<FileResponse[]> {
+        const params: any = { workspace_id: workspaceId };
+        if (purpose) params.purpose = purpose;
+        const response = await this.client.get('/files', { params });
+        return response.data.data;
+    }
+}
+
+export interface FileResponse {
+    id: string;
+    filename: string;
+    purpose: string;
+    bytes: number;
+    created_at: string;
+}

package/src/index.ts

@@ -5,6 +5,9 @@ export { Langtune } from 'langtune';
 
 // Export Agent Client
 export { AgentClient, Agent, AgentRun, AgentCreate } from './agent';
+export { FileClient, FileResponse } from './files';
+export { TrainingClient, FineTuneJobCreate, FineTuneJobResponse } from './training';
+export { SubscriptionClient, SubscriptionInfo, FeatureCheck } from './subscription';
 
 // Export Types with Namespaces to avoid collisions
 import * as Vision from 'langvision';

package/src/subscription.ts

@@ -0,0 +1,45 @@
+export class SubscriptionClient {
+    private client: any; // AxiosInstance
+
+    constructor(config: { apiKey: string, baseUrl?: string }) {
+        const axios = require('axios');
+        this.client = axios.create({
+            baseURL: config.baseUrl || 'https://api.langtrain.ai/api/v1',
+            headers: {
+                'X-API-Key': config.apiKey,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async getStatus(): Promise<SubscriptionInfo> {
+        const response = await this.client.get('/subscription/status');
+        return response.data;
+    }
+
+    async checkFeature(feature: string): Promise<FeatureCheck> {
+        const response = await this.client.get(`/subscription/check/${feature}`);
+        return response.data;
+    }
+
+    async getLimits(): Promise<any> {
+        const response = await this.client.get('/subscription/analytics');
+        return response.data;
+    }
+}
+
+export interface SubscriptionInfo {
+    is_active: boolean;
+    plan: string;
+    plan_name: string;
+    expires_at?: string;
+    features: string[];
+    limits: any;
+}
+
+export interface FeatureCheck {
+    feature: string;
+    allowed: boolean;
+    limit?: number;
+    used?: number;
+}

package/src/training.ts

@@ -0,0 +1,63 @@
+export class TrainingClient {
+    private client: any; // AxiosInstance
+
+    constructor(config: { apiKey: string, baseUrl?: string }) {
+        const axios = require('axios');
+        this.client = axios.create({
+            baseURL: config.baseUrl || 'https://api.langtrain.ai/api/v1',
+            headers: {
+                'X-API-Key': config.apiKey,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async createJob(job: FineTuneJobCreate): Promise<FineTuneJobResponse> {
+        const response = await this.client.post('/finetune/jobs', job);
+        return response.data;
+    }
+
+    async listJobs(workspaceId: string, limit: number = 10): Promise<FineTuneJobList> {
+        const response = await this.client.get('/finetune/jobs', {
+            params: { workspace_id: workspaceId, limit }
+        });
+        return response.data;
+    }
+
+    async getJob(jobId: string): Promise<FineTuneJobResponse> {
+        const response = await this.client.get(`/finetune/jobs/${jobId}`);
+        return response.data;
+    }
+
+    async cancelJob(jobId: string): Promise<FineTuneJobResponse> {
+        const response = await this.client.post(`/finetune/jobs/${jobId}/cancel`);
+        return response.data;
+    }
+}
+
+export interface FineTuneJobCreate {
+    name?: string;
+    base_model: string;
+    model_id?: string;
+    dataset_id: string;
+    guardrail_id?: string;
+    task?: 'text' | 'vision';
+    training_method?: 'sft' | 'dpo' | 'rlhf' | 'lora' | 'qlora';
+    hyperparameters?: any;
+    [key: string]: any;
+}
+
+export interface FineTuneJobResponse {
+    id: string;
+    name: string;
+    status: string;
+    progress: number;
+    error_message?: string;
+    created_at: string;
+    [key: string]: any;
+}
+
+export interface FineTuneJobList {
+    data: FineTuneJobResponse[];
+    has_more: boolean;
+}