@smartluvon/mcp 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+# Smartluvon MCP
+
+MCP-сервер [Smartluvon](https://smartluvon.ru) — генерация изображений, видео и аудио AI-моделями прямо из Claude, Cursor и любого другого MCP-клиента.
+
+## Быстрый старт
+
+1. Получите API-ключ: профиль на smartluvon.ru → «API-ключи» → «Создать ключ» (ключ вида `sl-...` показывается один раз).
+2. Добавьте сервер в конфиг MCP-клиента:
+
+```json
+{
+	"mcpServers": {
+		"smartluvon": {
+			"command": "npx",
+			"args": ["-y", "@smartluvon/mcp"],
+			"env": {
+				"SMARTLUVON_API_KEY": "sl-..."
+			}
+		}
+	}
+}
+```
+
+## Инструменты
+
+| Инструмент | Описание |
+|---|---|
+| `list_models` | Список доступных моделей (фильтр по `type`: image / video / audio) |
+| `generate_image` | Генерация/редактирование изображений (`imageUrls` — входные картинки) |
+| `generate_video` | Генерация видео (text-to-video, image-to-video через `imageUrls`) |
+| `generate_audio` | Музыка и озвучка (TTS) |
+| `get_generation` | Статус и ссылки на результаты по id |
+| `wait_generation` | Дождаться завершения генерации (поллинг) |
+| `list_generations` | Список ваших генераций |
+| `get_balance` | Баланс токенов |
+| `calc_price` | Стоимость генерации в токенах без запуска |
+
+Типовой сценарий: `list_models` → `generate_image` → `wait_generation` → ссылки на файлы.
+
+## Переменные окружения
+
+| Переменная | Описание |
+|---|---|
+| `SMARTLUVON_API_KEY` | Персональный API-ключ (`sl-...`), обязательно |
+| `SMARTLUVON_API_URL` | База API (по умолчанию `https://api.smartluvon.ru`) |
+
+## Лицензия
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Thin client for the Smartluvon public /v1 API.
+ * Auth: personal API key (`sl-...`) via Authorization: Bearer.
+ */
+export interface V1Model {
+    id: string;
+    key: string | null;
+    name: string;
+    description: string | null;
+    type: 'image' | 'video' | 'audio' | 'text' | 'model_3d';
+    tags: string[];
+}
+export interface V1GenerationResult {
+    url: string;
+    type: string;
+    thumbnailUrl: string | null;
+}
+export interface V1Generation {
+    id: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    outputType: string;
+    results: V1GenerationResult[];
+    costTokens: number;
+    errorCodes: string[];
+    createdAt: string;
+}
+export interface V1Me {
+    email: string;
+    name: string;
+    tokenBalance: number;
+}
+export interface V1GenerateRequest {
+    model: string;
+    prompt: string;
+    imageUrls?: string[];
+    videoUrls?: string[];
+    audioUrl?: string;
+    numImages?: number;
+    options?: Record<string, unknown>;
+}
+export declare class SmartluvonApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare class SmartluvonClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    listModels(type?: string): Promise<V1Model[]>;
+    me(): Promise<V1Me>;
+    generate(body: V1GenerateRequest): Promise<V1Generation>;
+    getGeneration(id: string): Promise<V1Generation>;
+    listGenerations(params: {
+        page?: number;
+        limit?: number;
+        status?: string;
+    }): Promise<{
+        items: V1Generation[];
+        meta: unknown;
+    }>;
+    price(body: V1GenerateRequest): Promise<unknown>;
+    /** Poll a generation until it completes/fails or the timeout elapses. */
+    waitGeneration(id: string, timeoutMs: number, intervalMs?: number): Promise<V1Generation>;
+}

package/dist/api.js

@@ -0,0 +1,84 @@
+/**
+ * Thin client for the Smartluvon public /v1 API.
+ * Auth: personal API key (`sl-...`) via Authorization: Bearer.
+ */
+export class SmartluvonApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export class SmartluvonClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async request(method, path, body) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        const text = await response.text();
+        let data;
+        try {
+            data = text ? JSON.parse(text) : undefined;
+        }
+        catch {
+            data = text;
+        }
+        if (!response.ok) {
+            const message = typeof data === 'object' && data !== null && 'message' in data
+                ? String(Array.isArray(data.message) ? data.message.join('; ') : data.message)
+                : `HTTP ${response.status}`;
+            throw new SmartluvonApiError(response.status, message);
+        }
+        return data;
+    }
+    listModels(type) {
+        const query = type ? `?type=${encodeURIComponent(type)}` : '';
+        return this.request('GET', `/v1/models${query}`);
+    }
+    me() {
+        return this.request('GET', '/v1/me');
+    }
+    generate(body) {
+        return this.request('POST', '/v1/generations', body);
+    }
+    getGeneration(id) {
+        return this.request('GET', `/v1/generations/${encodeURIComponent(id)}`);
+    }
+    listGenerations(params) {
+        const query = new URLSearchParams();
+        if (params.page)
+            query.set('page', String(params.page));
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.status)
+            query.set('status', params.status);
+        const qs = query.toString();
+        return this.request('GET', `/v1/generations${qs ? `?${qs}` : ''}`);
+    }
+    price(body) {
+        return this.request('POST', '/v1/price', body);
+    }
+    /** Poll a generation until it completes/fails or the timeout elapses. */
+    async waitGeneration(id, timeoutMs, intervalMs = 3000) {
+        const deadline = Date.now() + timeoutMs;
+        let generation = await this.getGeneration(id);
+        while (generation.status === 'pending' || generation.status === 'processing') {
+            if (Date.now() >= deadline) {
+                return generation;
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+            generation = await this.getGeneration(id);
+        }
+        return generation;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { zodToJsonSchema } from './zod-to-json-schema.js';
+import { SmartluvonApiError, SmartluvonClient } from './api.js';
+const API_URL = process.env.SMARTLUVON_API_URL || 'https://api.smartluvon.ru';
+const API_KEY = process.env.SMARTLUVON_API_KEY || '';
+if (!API_KEY) {
+    console.error('SMARTLUVON_API_KEY is not set. Create a key in your Smartluvon profile and pass it via the env config of this MCP server.');
+}
+const client = new SmartluvonClient(API_URL, API_KEY);
+const optionsSchema = z
+    .record(z.unknown())
+    .optional()
+    .describe('Extra model options, e.g. { "aspectRatio": "16:9", "resolution": "1080p", "seed": 42 }');
+const toolSchemas = {
+    list_models: z.object({
+        type: z
+            .enum(['image', 'video', 'audio'])
+            .optional()
+            .describe('Filter models by media type'),
+    }),
+    generate_image: z.object({
+        model: z.string().describe('Model key or id (see list_models with type=image)'),
+        prompt: z.string().describe('Text prompt'),
+        imageUrls: z
+            .array(z.string().url())
+            .max(10)
+            .optional()
+            .describe('Input/reference image URLs (for editing or reference-based generation)'),
+        numImages: z.number().int().min(1).max(4).optional().describe('Number of images (default 1)'),
+        options: optionsSchema,
+    }),
+    generate_video: z.object({
+        model: z.string().describe('Model key or id (see list_models with type=video)'),
+        prompt: z.string().describe('Text prompt'),
+        imageUrls: z
+            .array(z.string().url())
+            .max(10)
+            .optional()
+            .describe('Input image URLs (start frame / references) for image-to-video'),
+        videoUrls: z
+            .array(z.string().url())
+            .max(4)
+            .optional()
+            .describe('Input video URLs (for video-to-video models)'),
+        options: optionsSchema,
+    }),
+    generate_audio: z.object({
+        model: z.string().describe('Model key or id (see list_models with type=audio)'),
+        prompt: z.string().describe('Text to speak (TTS) or music description'),
+        audioUrl: z.string().url().optional().describe('Input audio URL (voice change etc.)'),
+        options: optionsSchema,
+    }),
+    get_generation: z.object({
+        id: z.string().describe('Generation id'),
+    }),
+    wait_generation: z.object({
+        id: z.string().describe('Generation id'),
+        timeoutSec: z
+            .number()
+            .int()
+            .min(5)
+            .max(600)
+            .optional()
+            .describe('Max seconds to wait (default 300)'),
+    }),
+    list_generations: z.object({
+        page: z.number().int().min(1).optional().describe('Page (default 1)'),
+        limit: z.number().int().min(1).max(100).optional().describe('Items per page (default 25)'),
+        status: z
+            .enum(['pending', 'processing', 'completed', 'failed'])
+            .optional()
+            .describe('Filter by status'),
+    }),
+    get_balance: z.object({}),
+    calc_price: z.object({
+        model: z.string().describe('Model key or id'),
+        prompt: z.string().optional().describe('Prompt (some models price by length)'),
+        numImages: z.number().int().min(1).max(4).optional(),
+        options: optionsSchema,
+    }),
+};
+const toolDescriptions = {
+    list_models: 'List available Smartluvon generation models. Returns model key/id, name, description and media type. Use the key as `model` in generate_* tools.',
+    generate_image: 'Start an image generation (text-to-image, or image editing when imageUrls are provided). Returns a generation id — use wait_generation to get result URLs.',
+    generate_video: 'Start a video generation (text-to-video, or image-to-video when imageUrls are provided). Returns a generation id — use wait_generation to get result URLs. Video can take several minutes.',
+    generate_audio: 'Start an audio generation (music or text-to-speech depending on the model). Returns a generation id — use wait_generation to get result URLs.',
+    get_generation: 'Get the current status and result URLs of a generation by id.',
+    wait_generation: 'Poll a generation until it completes or fails (or the timeout elapses) and return its status and result URLs.',
+    list_generations: 'List your recent generations with optional status filter and pagination.',
+    get_balance: 'Get your Smartluvon profile and token balance.',
+    calc_price: 'Calculate how many tokens a generation would cost without running it.',
+};
+function formatGeneration(generation) {
+    return {
+        id: generation.id,
+        status: generation.status,
+        outputType: generation.outputType,
+        costTokens: generation.costTokens,
+        results: generation.results,
+        ...(generation.errorCodes?.length ? { errorCodes: generation.errorCodes } : {}),
+        createdAt: generation.createdAt,
+    };
+}
+async function handleTool(name, args) {
+    const parsed = toolSchemas[name].parse(args ?? {});
+    switch (name) {
+        case 'list_models': {
+            const { type } = parsed;
+            return client.listModels(type);
+        }
+        case 'generate_image': {
+            const { model, prompt, imageUrls, numImages, options } = parsed;
+            const generation = await client.generate({ model, prompt, imageUrls, numImages, options });
+            return formatGeneration(generation);
+        }
+        case 'generate_video': {
+            const { model, prompt, imageUrls, videoUrls, options } = parsed;
+            const generation = await client.generate({ model, prompt, imageUrls, videoUrls, options });
+            return formatGeneration(generation);
+        }
+        case 'generate_audio': {
+            const { model, prompt, audioUrl, options } = parsed;
+            const generation = await client.generate({ model, prompt, audioUrl, options });
+            return formatGeneration(generation);
+        }
+        case 'get_generation': {
+            const { id } = parsed;
+            return formatGeneration(await client.getGeneration(id));
+        }
+        case 'wait_generation': {
+            const { id, timeoutSec = 300 } = parsed;
+            const generation = await client.waitGeneration(id, timeoutSec * 1000);
+            if (generation.status === 'pending' || generation.status === 'processing') {
+                return {
+                    ...formatGeneration(generation),
+                    note: `Still ${generation.status} after ${timeoutSec}s — call wait_generation again.`,
+                };
+            }
+            return formatGeneration(generation);
+        }
+        case 'list_generations': {
+            const { page, limit, status } = parsed;
+            const { items, meta } = await client.listGenerations({ page, limit, status });
+            return { items: items.map(formatGeneration), meta };
+        }
+        case 'get_balance':
+            return client.me();
+        case 'calc_price': {
+            const { model, prompt, numImages, options } = parsed;
+            return client.price({ model, prompt: prompt ?? '', numImages, options });
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+const server = new Server({ name: 'smartluvon', version: '0.1.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: Object.keys(toolSchemas).map((name) => ({
+        name,
+        description: toolDescriptions[name],
+        inputSchema: zodToJsonSchema(toolSchemas[name]),
+    })),
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        if (!(name in toolSchemas)) {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        const result = await handleTool(name, args);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        const message = error instanceof SmartluvonApiError
+            ? `API error ${error.status}: ${error.message}`
+            : error instanceof Error
+                ? error.message
+                : String(error);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`Smartluvon MCP server running on stdio (url=${API_URL})`);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/zod-to-json-schema.d.ts

@@ -0,0 +1,12 @@
+import { ZodTypeAny } from 'zod';
+type JsonSchema = {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    description?: string;
+    enum?: string[];
+    items?: JsonSchema;
+    additionalProperties?: boolean;
+};
+export declare function zodToJsonSchema(schema: ZodTypeAny): JsonSchema;
+export {};

package/dist/zod-to-json-schema.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export function zodToJsonSchema(schema) {
+    if (schema instanceof z.ZodObject) {
+        const shape = schema.shape;
+        const properties = {};
+        const required = [];
+        for (const [key, value] of Object.entries(shape)) {
+            const propSchema = zodTypeToJsonSchema(value);
+            properties[key] = propSchema;
+            if (!isOptional(value)) {
+                required.push(key);
+            }
+        }
+        return {
+            type: 'object',
+            properties,
+            required: required.length > 0 ? required : undefined,
+        };
+    }
+    return zodTypeToJsonSchema(schema);
+}
+function isOptional(schema) {
+    if (schema instanceof z.ZodOptional)
+        return true;
+    if (schema instanceof z.ZodNullable)
+        return true;
+    if (schema._def?.typeName === 'ZodOptional')
+        return true;
+    return false;
+}
+function unwrapOptional(schema) {
+    if (schema instanceof z.ZodOptional) {
+        return schema.unwrap();
+    }
+    if (schema instanceof z.ZodNullable) {
+        return schema.unwrap();
+    }
+    return schema;
+}
+function zodTypeToJsonSchema(schema) {
+    const unwrapped = unwrapOptional(schema);
+    const description = schema._def?.description ||
+        unwrapped._def?.description;
+    if (unwrapped instanceof z.ZodString) {
+        return { type: 'string', description };
+    }
+    if (unwrapped instanceof z.ZodNumber) {
+        return { type: 'number', description };
+    }
+    if (unwrapped instanceof z.ZodBoolean) {
+        return { type: 'boolean', description };
+    }
+    if (unwrapped instanceof z.ZodEnum) {
+        return {
+            type: 'string',
+            enum: unwrapped._def.values,
+            description,
+        };
+    }
+    if (unwrapped instanceof z.ZodArray) {
+        return {
+            type: 'array',
+            items: zodTypeToJsonSchema(unwrapped._def.type),
+            description,
+        };
+    }
+    if (unwrapped instanceof z.ZodRecord) {
+        return {
+            type: 'object',
+            additionalProperties: true,
+            description,
+        };
+    }
+    if (unwrapped instanceof z.ZodObject) {
+        return zodToJsonSchema(unwrapped);
+    }
+    if (unwrapped instanceof z.ZodUnknown || unwrapped instanceof z.ZodAny) {
+        return { description };
+    }
+    return { type: 'string', description };
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+	"name": "@smartluvon/mcp",
+	"version": "0.1.0",
+	"description": "Smartluvon MCP server — generate images, video and audio with Smartluvon AI models",
+	"type": "module",
+	"main": "dist/index.js",
+	"bin": {
+		"smartluvon-mcp": "dist/index.js"
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsc",
+		"start": "node dist/index.js",
+		"dev": "tsx src/index.ts",
+		"prepublishOnly": "npm run build",
+		"publish:package": "npm run build && npm publish"
+	},
+	"keywords": [
+		"mcp",
+		"smartluvon",
+		"ai",
+		"image-generation",
+		"video-generation"
+	],
+	"license": "MIT",
+	"engines": {
+		"node": ">=18"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.12.0",
+		"zod": "^3.24.0"
+	},
+	"devDependencies": {
+		"@types/node": "^22.10.0",
+		"tsx": "^4.19.0",
+		"typescript": "^5.7.0"
+	}
+}