langtrain 0.1.10 → 0.1.12

package/package.json

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

package/src/agent.ts

@@ -43,6 +43,20 @@ export class AgentClient {
         return response.data.agents;
     }
 
+    async get(agentId: string): Promise<Agent> {
+        const response = await this.client.get<Agent>(`/agents/${agentId}`);
+        return response.data;
+    }
+
+    async create(agent: AgentCreate): Promise<Agent> {
+        const response = await this.client.post<Agent>('/agents/', agent);
+        return response.data;
+    }
+
+    async delete(agentId: string): Promise<void> {
+        await this.client.delete(`/agents/${agentId}`);
+    }
+
     async execute(agentId: string, input: any, messages: any[] = [], conversationId?: string): Promise<AgentRun> {
         const response = await this.client.post<AgentRun>(`/agents/${agentId}/execute`, {
             input,
@@ -52,3 +66,19 @@ export class AgentClient {
         return response.data;
     }
 }
+
+export interface AgentConfig {
+    system_prompt?: string;
+    temperature?: number;
+    max_tokens?: number;
+    tools?: string[];
+    [key: string]: any;
+}
+
+export interface AgentCreate {
+    workspace_id: string; // UUID
+    name: string;
+    description?: string;
+    model_id?: string; // UUID
+    config?: AgentConfig;
+}

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 } 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,11 +66,14 @@ 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),
             'vision-generate': (c) => handleVisionGenerate(c.vision),
             'agent-list': (c) => handleAgentList(c.agent),
+            'agent-create': (c) => handleAgentCreate(c.agent),
+            'agent-delete': (c) => handleAgentDelete(c.agent),
             'exit': async () => { outro('Goodbye!'); process.exit(0); },
         };
 
@@ -78,6 +83,8 @@ async function main() {
                 options: [
                     { value: 'group-agents', label: '🤖 Agents (Server)', hint: 'Chat with custom agents' },
                     { value: 'agent-list', label: '  ↳ List & Run Agents' },
+                    { value: 'agent-create', label: '  ↳ Create New Agent' },
+                    { value: 'agent-delete', label: '  ↳ Delete Agent' },
 
                     { value: 'group-tune', label: '🧠 Langtune (LLM)', hint: 'Fine-tuning & Text Generation' },
                     { value: 'tune-finetune', label: '  ↳ Fine-tune Text Model' },
@@ -140,6 +147,157 @@ 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 || value.length === 0) return 'API Key is required';
+        },
+    });
+    if (isCancel(name)) return;
+
+    const description = await text({
+        message: 'Description:',
+        placeholder: 'e.g. A helpful support assistant',
+    });
+    if (isCancel(description)) return;
+
+    const systemPrompt = await text({
+        message: 'System Prompt:',
+        placeholder: 'e.g. You are a helpful assistant.',
+        initialValue: 'You are a helpful assistant.'
+    });
+    if (isCancel(systemPrompt)) return;
+
+    const s = spinner();
+    s.start('Creating agent...');
+
+    try {
+        // We need a workspace ID. server usually infers it from API key context if not provided?
+        // But the schema says workspace_id is required in AgentCreate.
+        // The server implementation of create_agent takes AgentCreate which has workspace_id.
+        // However, standard users might not know their exact workspace UUID. 
+        // We might need to fetch it or rely on server to fill it if we made it optional in schema (which we didn't).
+        // EDIT: Let's fetch one agent to get the workspace_id or assume one?
+        // Better: List agents, get workspace_id from first one. Hacky but works for single-workspace users.
+        // Use 'default' or similar if server supports it?
+        // Checking agents.py: verify_api_key returns workspace_id.
+        // But create_agent payload requires it.
+        // I'll try to fetch list first to get workspace ID. If list empty, we are stuck?
+        // Wait, list_agents returns `AgentListResponse` which doesn't explicitly return workspace_id at top level, but agents have it.
+        // If no agents, we can't guess it.
+        // Maybe I should fetch user profile? No endpoint for that in CLI yet.
+        // I'll try to pass a placeholder and hope server ignores it if it uses context?
+        // Server code: `workspace_id=agent_in.workspace_id`. It uses payload.
+        // I might need to ask user for workspace ID or update server to be smarter.
+        // For now, I'll attempt to LIST agents to get a workspace ID.
+
+        const agents = await client.list();
+        let workspaceId = "";
+        if (agents.length > 0) {
+            workspaceId = agents[0].workspace_id;
+        } else {
+            // Fallback: Ask user or fail?
+            // Or maybe decoding JWT/API key client side? No.
+            // I'll prompt for it if not found, with a hint.
+            s.stop(yellow('Workspace ID needed (no existing agents found).'));
+            const wid = await text({
+                message: 'Enter Workspace ID (UUID):',
+                validate(value) {
+                    if (!value || value.length === 0) return 'Required';
+                },
+            });
+            if (isCancel(wid)) return;
+            workspaceId = wid as string;
+            s.start('Creating agent...');
+        }
+
+        const agent = await client.create({
+            workspace_id: workspaceId,
+            name: name as string,
+            description: description as string,
+            config: {
+                system_prompt: systemPrompt as string,
+                model: 'gpt-4o' // Default or prompt? simplified
+            }
+        });
+        s.stop(green(`Agent "${agent.name}" created successfully! ID: ${agent.id}`));
+    } catch (e: any) {
+        s.stop(red('Failed to create agent.'));
+        throw e;
+    }
+}
+
+async function handleAgentDelete(client: AgentClient) {
+    const s = spinner();
+    s.start('Fetching agents...');
+    const agents = await client.list();
+    s.stop(`Found ${agents.length} agents`);
+
+    if (agents.length === 0) {
+        intro(yellow('No agents to delete.'));
+        return;
+    }
+
+    const agentId = await select({
+        message: 'Select an agent to DELETE:',
+        options: agents.map(a => ({ value: a.id, label: a.name, hint: a.description || 'No description' }))
+    });
+
+    if (isCancel(agentId)) return;
+
+    const confirm = await select({
+        message: `Are you sure you want to delete this agent?`,
+        options: [
+            { value: 'yes', label: 'Yes, delete it', hint: 'Cannot be undone' },
+            { value: 'no', label: 'No, keep it' }
+        ]
+    });
+
+    if (confirm !== 'yes') {
+        intro(gray('Deletion cancelled.'));
+        return;
+    }
+
+    const d = spinner();
+    d.start('Deleting agent...');
+    try {
+        await client.delete(agentId as string);
+        d.stop(green('Agent deleted successfully.'));
+    } catch (e: any) {
+        d.stop(red('Failed to delete agent.'));
+        throw e;
+    }
+}
+
 async function handleAgentList(client: AgentClient) {
     const s = spinner();
     s.start('Fetching agents...');
@@ -225,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. 
@@ -302,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

@@ -4,7 +4,10 @@ export { Langvision } from 'langvision';
 export { Langtune } from 'langtune';
 
 // Export Agent Client
-export { AgentClient, Agent, AgentRun } from './agent';
+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;
+}