langtrain 0.1.5 → 0.1.9

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "langtrain",
-  "version": "0.1.5",
+  "version": "0.1.9",
   "description": "Unified JavaScript SDK for Langtrain Ecosystem",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "langtrain": "./dist/cli.js"
+  },
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
@@ -26,9 +29,18 @@
   "author": "Langtrain AI",
   "license": "MIT",
   "devDependencies": {
-    "langvision": "file:../langvision/js",
+    "@types/node": "^25.2.3",
     "langtune": "file:../langtune/js",
+    "langvision": "file:../langvision/js",
     "tsup": "^8.0.2",
     "typescript": "^5.4.2"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "axios": "^1.13.5",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
+    "gradient-string": "^3.0.0",
+    "kleur": "^4.1.5"
   }
 }

package/src/agent.ts

@@ -0,0 +1,54 @@
+import axios, { AxiosInstance } from 'axios';
+
+export interface Agent {
+    id: string;
+    workspace_id: string;
+    name: string;
+    description?: string;
+    model_id?: string;
+    config: any;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface AgentRun {
+    id: string;
+    conversation_id: string;
+    success: boolean;
+    output?: any;
+    error?: string;
+    latency_ms: number;
+    tokens_used: number;
+}
+
+export class AgentClient {
+    private client: AxiosInstance;
+
+    constructor(private config: { apiKey: string, baseUrl?: string }) {
+        this.client = axios.create({
+            baseURL: config.baseUrl || 'https://api.langtrain.ai/api/v1',
+            headers: {
+                'X-API-Key': config.apiKey,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async list(workspaceId?: string): Promise<Agent[]> {
+        const params: any = {};
+        if (workspaceId) params.workspace_id = workspaceId;
+
+        const response = await this.client.get<{ agents: Agent[] }>('/agents', { params });
+        return response.data.agents;
+    }
+
+    async execute(agentId: string, input: any, messages: any[] = [], conversationId?: string): Promise<AgentRun> {
+        const response = await this.client.post<AgentRun>(`/agents/${agentId}/execute`, {
+            input,
+            messages,
+            conversation_id: conversationId
+        });
+        return response.data;
+    }
+}

package/src/cli.ts

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import { intro, outro, select, text, spinner, isCancel, 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 fs from 'fs';
+import path from 'path';
+import os from 'os';
+import gradient from 'gradient-string';
+
+// Configuration
+const CONFIG_DIR = path.join(os.homedir(), '.langtrain');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function getConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    } catch {
+        return {};
+    }
+}
+
+function saveConfig(config: any) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+// Initialize clients with config
+// Clients are initialized inside main loop to support re-login
+
+async function main() {
+    const program = new Command();
+
+    program
+        .name('langtrain')
+        .description('Langtrain CLI for AI Model Fine-tuning and Generation')
+        .version('0.1.9');
+
+    program.action(async () => {
+        console.clear();
+
+        // Gradient Banner
+        const banner = `
+    ██╗      █████╗ ███╗   ██╗ ██████╗████████╗██████╗  █████╗ ██╗███╗   ██╗
+    ██║     ██╔══██╗████╗  ██║██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██║████╗  ██║
+    ██║     ███████║██╔██╗ ██║██║  ███╗  ██║   ██████╔╝███████║██║██╔██╗ ██║
+    ██║     ██╔══██║██║╚██╗██║██║   ██║  ██║   ██╔══██╗██╔══██║██║██║╚██╗██║
+    ███████╗██║  ██║██║ ╚████║╚██████╔╝  ██║   ██║  ██║██║  ██║██║██║ ╚████║
+    ╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚═════╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝
+    `;
+        console.log(gradient(['#00DC82', '#36E4DA', '#0047E1'])(banner)); // Custom Langtrain Green-Cyan-Blue gradient
+        intro(`${bgCyan(black(' Langtrain SDK v0.1.9 '))}`);
+
+        // Check auth
+        const config = getConfig();
+        if (!config.apiKey) {
+            intro(yellow('Authentication required'));
+            const apiKey = await password({
+                message: 'Enter your Langtrain API Key:',
+                validate(value) {
+                    if (!value || value.length === 0) return 'API Key is required';
+                },
+            });
+
+            if (isCancel(apiKey)) {
+                cancel('Operation cancelled');
+                process.exit(0);
+            }
+
+            saveConfig({ ...config, apiKey });
+            intro(green('Successfully logged in!'));
+        }
+
+        while (true) {
+            const operation = await select({
+                message: 'Select an operation:',
+                options: [
+                    { value: 'group-agents', label: '🤖 Agents (Server)', hint: 'Chat with custom agents' },
+                    { value: 'agent-list', label: '  ↳ List & Run Agents' },
+
+                    { value: 'group-tune', label: '🧠 Langtune (LLM)', hint: 'Fine-tuning & Text Generation' },
+                    { value: 'tune-finetune', label: '  ↳ Fine-tune Text Model' },
+                    { value: 'tune-generate', label: '  ↳ Generate Text' },
+
+                    { value: 'group-vision', label: '👁️ Langvision (Vision)', hint: 'Vision Analysis & Tuning' },
+                    { value: 'vision-finetune', label: '  ↳ Fine-tune Vision Model' },
+                    { value: 'vision-generate', label: '  ↳ Generate Vision Response' },
+
+                    { value: 'group-settings', label: '⚙️ Settings' },
+                    { value: 'login', label: '  ↳ Update API Key' },
+                    { value: 'exit', label: '  ↳ Exit' }
+                ],
+            });
+
+            if (isCancel(operation) || operation === 'exit') {
+                outro('Goodbye!');
+                process.exit(0);
+            }
+
+            if (typeof operation === 'string' && operation.startsWith('group-')) {
+                // Header selected, just loop
+                continue;
+            }
+
+            try {
+                // Re-read config & re-init clients
+                const currentConfig = getConfig();
+                const currentVision = new Langvision({ apiKey: currentConfig.apiKey });
+                const currentTune = new Langtune({ apiKey: currentConfig.apiKey });
+                const currentAgent = new AgentClient({ apiKey: currentConfig.apiKey, baseUrl: currentConfig.baseUrl });
+
+                if (operation === 'login') {
+                    await handleLogin();
+                } else if (operation === 'tune-finetune') {
+                    await handleTuneFinetune(currentTune);
+                } else if (operation === 'tune-generate') {
+                    await handleTuneGenerate(currentTune);
+                } else if (operation === 'vision-finetune') {
+                    await handleVisionFinetune(currentVision);
+                } else if (operation === 'vision-generate') {
+                    await handleVisionGenerate(currentVision);
+                } else if (operation === 'agent-list') {
+                    await handleAgentList(currentAgent);
+                }
+            } catch (error: any) {
+                outro(red(`Error: ${error.message}`));
+                // Don't exit, just loop back to menu
+            }
+        }
+    });
+
+    program.parse(process.argv);
+}
+
+async function handleLogin() {
+    const apiKey = await password({
+        message: 'Enter your new Langtrain API Key:',
+        validate(value) {
+            if (!value || value.length === 0) return 'API Key is required';
+        },
+    });
+
+    if (isCancel(apiKey)) cancel('Operation cancelled');
+
+    const config = getConfig();
+    saveConfig({ ...config, apiKey });
+    intro(green('API Key updated successfully!'));
+}
+
+async function handleAgentList(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 found in your workspace.'));
+        return;
+    }
+
+    const agentId = await select({
+        message: 'Select an agent to run:',
+        options: agents.map(a => ({ value: a.id, label: a.name, hint: a.description || 'No description' }))
+    });
+
+    if (isCancel(agentId)) return;
+
+    await handleAgentRun(client, agentId as string, agents.find(a => a.id === agentId)?.name || 'Agent');
+}
+
+async function handleAgentRun(client: AgentClient, agentId: string, agentName: string) {
+    intro(bgCyan(black(` Chatting with ${agentName} `)));
+    console.log(gray('Type "exit" to quit conversation.'));
+
+    let conversationId: string | undefined = undefined;
+
+    while (true) {
+        const input = await text({
+            message: 'You:',
+            placeholder: 'Type a message...',
+        });
+
+        if (isCancel(input) || input === 'exit') {
+            break;
+        }
+
+        const s = spinner();
+        s.start('Agent is thinking...');
+        try {
+            const result = await client.execute(agentId, { prompt: input }, [], conversationId);
+            s.stop();
+
+            if (result.output && result.output.response) {
+                console.log(gradient.pastel(`Agent: ${result.output.response}`));
+            } else {
+                console.log(gradient.pastel(`Agent: ${JSON.stringify(result.output)}`));
+            }
+
+            conversationId = result.conversation_id;
+        } catch (e: any) {
+            s.stop(red('Error running agent.'));
+            console.error(e);
+        }
+    }
+}
+
+
+// Handler for Langtune Fine-tuning
+async function handleTuneFinetune(tune: Langtune) {
+    const model = await text({
+        message: 'Enter base model (e.g., gpt-3.5-turbo):',
+        placeholder: 'gpt-3.5-turbo',
+        validate(value) {
+            if (!value || value.length === 0) return 'Value is required!';
+        },
+    });
+    if (isCancel(model)) cancel('Operation cancelled.');
+
+    const trainFile = await text({
+        message: 'Enter path to training file:',
+        placeholder: './data.jsonl',
+        validate(value) {
+            if (!value || value.length === 0) return 'Value is required!';
+        },
+    });
+    if (isCancel(trainFile)) cancel('Operation cancelled.');
+
+    const epochs = await text({
+        message: 'Num Epochs:',
+        placeholder: '3',
+        initialValue: '3'
+    });
+    if (isCancel(epochs)) cancel('Operation cancelled.');
+
+    const s = spinner();
+    s.start('Connecting to Langtrain Cloud...');
+    await new Promise(r => setTimeout(r, 800)); // Simulatoin
+    s.message('Starting fine-tuning job...');
+
+    try {
+        // Check if FinetuneConfig types match what's needed. 
+        // Casting to any to bypass strict type checking for this demo or ensure types are imported correctly.
+        // In a real scenario, we'd construct the full config object.
+        const config: any = {
+            model: model as string,
+            trainFile: trainFile as string,
+            preset: 'default', // simplified
+            epochs: parseInt(epochs as string),
+            batchSize: 1,
+            learningRate: 2e-5,
+            loraRank: 16,
+            outputDir: './output'
+        };
+
+        await tune.finetune(config);
+        s.stop(green('Fine-tuning job started successfully! 🚀'));
+    } catch (e: any) {
+        s.stop(red('Failed to start job.'));
+        throw e;
+    }
+}
+
+// Handler for Langtune Generation
+async function handleTuneGenerate(tune: Langtune) {
+    const model = await text({
+        message: 'Enter model path:',
+        placeholder: './output/model',
+        initialValue: './output/model'
+    });
+    if (isCancel(model)) cancel('Operation cancelled');
+
+    const prompt = await text({
+        message: 'Enter prompt:',
+        placeholder: 'Hello world',
+    });
+    if (isCancel(prompt)) cancel('Operation cancelled');
+
+    const s = spinner();
+    s.start('Connecting to Langtrain Inference API...');
+
+    try {
+        const response = await tune.generate(model as string, { prompt: prompt as string });
+        s.stop('Generation complete');
+        intro('Response:');
+        console.log(gradient.pastel(response));
+    } catch (e: any) {
+        s.stop(red('Generation failed.'));
+        throw e;
+    }
+}
+
+// Handler for Langvision Fine-tuning
+async function handleVisionFinetune(vision: Langvision) {
+    const model = await text({
+        message: 'Enter base vision model:',
+        placeholder: 'llava-v1.5-7b',
+        initialValue: 'llava-v1.5-7b'
+    });
+    if (isCancel(model)) cancel('Operation cancelled');
+
+    const dataset = await text({
+        message: 'Enter dataset path:',
+        placeholder: './dataset',
+    });
+    if (isCancel(dataset)) cancel('Operation cancelled');
+
+    const epochs = await text({
+        message: 'Num Epochs:',
+        placeholder: '3',
+        initialValue: '3'
+    });
+
+    const s = spinner();
+    s.start('Analyzing dataset structure...');
+    await new Promise(r => setTimeout(r, 800));
+    s.message('Starting vision fine-tuning on Langtrain Cloud...');
+
+    try {
+        const config: any = {
+            model: model as string,
+            dataset: dataset as string,
+            epochs: parseInt(epochs as string),
+            batchSize: 1,
+            learningRate: 2e-5,
+            loraRank: 16,
+            outputDir: './vision-output'
+        };
+        await vision.finetune(config);
+        s.stop(green('Vision fine-tuning started successfully! 👁️'));
+    } catch (e: any) {
+        s.stop(red('Failed to start vision job.'));
+        throw e;
+    }
+}
+
+// Handler for Langvision Generation
+async function handleVisionGenerate(vision: Langvision) {
+    const model = await text({
+        message: 'Enter model path:',
+        placeholder: './vision-output/model',
+        initialValue: './vision-output/model'
+    });
+    if (isCancel(model)) cancel('Operation cancelled');
+
+    const prompt = await text({
+        message: 'Enter prompt/image path:', // Simplified for CLI
+        placeholder: 'Describe this image...',
+    });
+    if (isCancel(prompt)) cancel('Operation cancelled');
+
+    const s = spinner();
+    s.start('Uploading image and context...');
+    await new Promise(r => setTimeout(r, 600));
+    s.message('Generating vision response...');
+
+    try {
+        const response = await vision.generate(model as string, { prompt: prompt as string });
+        s.stop('Generation complete');
+        intro('Response:');
+        console.log(gradient.pastel(response));
+    } catch (e: any) {
+        s.stop(red('Generation failed.'));
+        throw e;
+    }
+}
+
+main().catch(console.error);

package/src/index.ts

@@ -3,8 +3,12 @@
 export { Langvision } from 'langvision';
 export { Langtune } from 'langtune';
 
+// Export Agent Client
+export { AgentClient, Agent, AgentRun } from './agent';
+
 // Export Types with Namespaces to avoid collisions
 import * as Vision from 'langvision';
 import * as Text from 'langtune';
+import * as AgentTypes from './agent';
 
-export { Vision, Text };
+export { Vision, Text, AgentTypes };

package/tsup.config.ts

@@ -1,7 +1,7 @@
 import { defineConfig } from 'tsup';
 
 export default defineConfig({
-    entry: ['src/index.ts'],
+    entry: ['src/index.ts', 'src/cli.ts'],
     format: ['cjs', 'esm'],
     dts: true,
     splitting: false,