langtrain 0.1.6 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langtrain",
-  "version": "0.1.6",
+  "version": "0.1.10",
   "description": "Unified JavaScript SDK for Langtrain Ecosystem",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -37,7 +37,10 @@
   },
   "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

@@ -1,64 +1,205 @@
 #!/usr/bin/env node
-import { intro, outro, select, text, spinner, isCancel, cancel } from '@clack/prompts';
-import { bgCyan, black, red, green } from 'kleur/colors';
+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 } from './index';
+import { Langvision, Langtune, AgentClient, Agent } from './index';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import gradient from 'gradient-string';
 
-// Initialize clients
-const vision = new Langvision();
-const tune = new Langtune();
+// 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));
+}
+
+const packageJson = require(path.join(__dirname, '../package.json'));
 
 async function main() {
     const program = new Command();
+    const version = packageJson.version;
 
     program
         .name('langtrain')
-        .description('Langtrain CLI for AI Model Fine-tuning and Generation')
-        .version('0.1.5');
+        .description(packageJson.description || 'Langtrain CLI for AI Model Fine-tuning and Generation')
+        .version(version);
 
     program.action(async () => {
         console.clear();
-        intro(`${bgCyan(black(' langtrain '))}`);
-
-        const operation = await select({
-            message: 'Select an operation:',
-            options: [
-                { value: 'tune-finetune', label: '🧠 Fine-tune Text Model (Langtune)' },
-                { value: 'tune-generate', label: '📝 Generate Text (Langtune)' },
-                { value: 'vision-finetune', label: '👁️ Fine-tune Vision Model (Langvision)' },
-                { value: 'vision-generate', label: '🖼️ Generate Vision Response (Langvision)' },
-                { value: 'exit', label: '🚪 Exit' }
-            ],
-        });
 
-        if (isCancel(operation) || operation === 'exit') {
-            outro('Goodbye!');
-            process.exit(0);
+        // Gradient Banner
+        const banner = `
+    ██╗      █████╗ ███╗   ██╗ ██████╗████████╗██████╗  █████╗ ██╗███╗   ██╗
+    ██║     ██╔══██╗████╗  ██║██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██║████╗  ██║
+    ██║     ███████║██╔██╗ ██║██║  ███╗  ██║   ██████╔╝███████║██║██╔██╗ ██║
+    ██║     ██╔══██║██║╚██╗██║██║   ██║  ██║   ██╔══██╗██╔══██║██║██║╚██╗██║
+    ███████╗██║  ██║██║ ╚████║╚██████╔╝  ██║   ██║  ██║██║  ██║██║██║ ╚████║
+    ╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚═════╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝
+    `;
+        console.log(gradient(['#00DC82', '#36E4DA', '#0047E1'])(banner)); // Custom Langtrain Green-Cyan-Blue gradient
+        intro(`${bgCyan(black(` Langtrain SDK v${version} `))}`);
+
+        // Check auth (only show login if missing)
+        const config = getConfig();
+        if (!config.apiKey) {
+            intro(yellow('Authentication required'));
+            await handleLogin();
         }
 
-        try {
-            if (operation === 'tune-finetune') {
-                await handleTuneFinetune();
-            } else if (operation === 'tune-generate') {
-                await handleTuneGenerate();
-            } else if (operation === 'vision-finetune') {
-                await handleVisionFinetune();
-            } else if (operation === 'vision-generate') {
-                await handleVisionGenerate();
+        // Operation Handlers Map (O(1) lookup)
+        const handlers: Record<string, (clients?: any) => Promise<void>> = {
+            'login': handleLogin,
+            '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),
+            'exit': async () => { outro('Goodbye!'); process.exit(0); },
+        };
+
+        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)) {
+                outro('Goodbye!');
+                process.exit(0);
             }
-        } catch (error: any) {
-            outro(red(`Error: ${error.message}`));
-            process.exit(1);
-        }
 
-        outro(green('Operation completed successfully!'));
+            if (typeof operation === 'string') {
+                if (operation.startsWith('group-')) continue;
+
+                // Execute handler via map lookup
+                const handler = handlers[operation];
+                if (handler) {
+                    try {
+                        // Re-read config & re-init clients freshly for each operation
+                        const currentConfig = getConfig();
+                        const clients = {
+                            vision: new Langvision({ apiKey: currentConfig.apiKey }),
+                            tune: new Langtune({ apiKey: currentConfig.apiKey }),
+                            agent: new AgentClient({ apiKey: currentConfig.apiKey, baseUrl: currentConfig.baseUrl })
+                        };
+
+                        await handler(clients);
+                    } catch (error: any) {
+                        outro(red(`Error: ${error.message}`));
+                    }
+                }
+            }
+        }
     });
 
     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() {
+async function handleTuneFinetune(tune: Langtune) {
     const model = await text({
         message: 'Enter base model (e.g., gpt-3.5-turbo):',
         placeholder: 'gpt-3.5-turbo',
@@ -85,10 +226,12 @@ async function handleTuneFinetune() {
     if (isCancel(epochs)) cancel('Operation cancelled.');
 
     const s = spinner();
-    s.start('Starting fine-tuning job...');
+    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.
+        // 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 = {
@@ -103,7 +246,7 @@ async function handleTuneFinetune() {
         };
 
         await tune.finetune(config);
-        s.stop(green('Fine-tuning job started!'));
+        s.stop(green('Fine-tuning job started successfully! 🚀'));
     } catch (e: any) {
         s.stop(red('Failed to start job.'));
         throw e;
@@ -111,7 +254,7 @@ async function handleTuneFinetune() {
 }
 
 // Handler for Langtune Generation
-async function handleTuneGenerate() {
+async function handleTuneGenerate(tune: Langtune) {
     const model = await text({
         message: 'Enter model path:',
         placeholder: './output/model',
@@ -126,13 +269,13 @@ async function handleTuneGenerate() {
     if (isCancel(prompt)) cancel('Operation cancelled');
 
     const s = spinner();
-    s.start('Generating response...');
+    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(response);
+        console.log(gradient.pastel(response));
     } catch (e: any) {
         s.stop(red('Generation failed.'));
         throw e;
@@ -140,7 +283,7 @@ async function handleTuneGenerate() {
 }
 
 // Handler for Langvision Fine-tuning
-async function handleVisionFinetune() {
+async function handleVisionFinetune(vision: Langvision) {
     const model = await text({
         message: 'Enter base vision model:',
         placeholder: 'llava-v1.5-7b',
@@ -161,7 +304,9 @@ async function handleVisionFinetune() {
     });
 
     const s = spinner();
-    s.start('Starting vision fine-tuning...');
+    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 = {
@@ -174,7 +319,7 @@ async function handleVisionFinetune() {
             outputDir: './vision-output'
         };
         await vision.finetune(config);
-        s.stop(green('Vision fine-tuning started!'));
+        s.stop(green('Vision fine-tuning started successfully! 👁️'));
     } catch (e: any) {
         s.stop(red('Failed to start vision job.'));
         throw e;
@@ -182,7 +327,7 @@ async function handleVisionFinetune() {
 }
 
 // Handler for Langvision Generation
-async function handleVisionGenerate() {
+async function handleVisionGenerate(vision: Langvision) {
     const model = await text({
         message: 'Enter model path:',
         placeholder: './vision-output/model',
@@ -197,13 +342,15 @@ async function handleVisionGenerate() {
     if (isCancel(prompt)) cancel('Operation cancelled');
 
     const s = spinner();
-    s.start('Generating vision response...');
+    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(response);
+        console.log(gradient.pastel(response));
     } catch (e: any) {
         s.stop(red('Generation failed.'));
         throw e;

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 };