anyfast 0.0.1

package/dist/client.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyFast = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+const chat_1 = require("./chat");
+const image_1 = require("./image");
+const video_1 = require("./video");
+const asset_1 = require("./asset");
+const file_1 = require("./file");
+const MIME_TYPES = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mov': 'video/quicktime',
+    '.avi': 'video/x-msvideo',
+    '.glb': 'model/gltf-binary',
+    '.gltf': 'model/gltf+json',
+    '.obj': 'model/obj',
+    '.fbx': 'application/octet-stream',
+};
+class AnyFast {
+    constructor(options = {}) {
+        this.apiKey = options.apiKey || process.env.ANYFAST_API_KEY || '';
+        if (!this.apiKey) {
+            throw new types_1.AnyFastError('API key is required. Pass it via options.apiKey or set ANYFAST_API_KEY environment variable.');
+        }
+        this.baseURL = options.baseURL || 'https://www.anyfast.ai';
+        this.gatewayURL = options.gatewayURL || 'https://www.anyfast.ai';
+        this.timeout = options.timeout || 30000;
+        this.chat = new chat_1.Chat(this);
+        this.image = new image_1.Image(this);
+        this.video = new video_1.Video(this);
+        this.asset = new asset_1.Asset(this);
+        this.file = new file_1.File(this);
+    }
+    async makeRequest(endpoint, options = {}) {
+        const url = `${this.baseURL}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+            ...options.headers,
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await (0, node_fetch_1.default)(url, {
+                method: options.method || 'GET',
+                headers,
+                body: options.body ? JSON.stringify(options.body) : undefined,
+                signal: controller.signal,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                throw new types_1.AnyFastError(data.message || `Request failed with status ${response.status}`, response.status, data.code, data);
+            }
+            return data;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async makeStreamingRequest(endpoint, options = {}) {
+        const url = `${this.baseURL}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: 'text/event-stream',
+            ...options.headers,
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await (0, node_fetch_1.default)(url, {
+                method: options.method || 'POST',
+                headers,
+                body: options.body ? JSON.stringify(options.body) : undefined,
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                clearTimeout(timeoutId);
+                const data = await response.json();
+                throw new types_1.AnyFastError(data.message || `Request failed with status ${response.status}`, response.status, data.code, data);
+            }
+            // Clear timeout for streaming - the stream manages its own lifecycle
+            clearTimeout(timeoutId);
+            return response;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+    }
+    async makeGatewayRequest(endpoint, options = {}) {
+        const url = `${this.gatewayURL}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'API-KEY': this.apiKey,
+            ...options.headers,
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await (0, node_fetch_1.default)(url, {
+                method: options.method || 'GET',
+                headers,
+                body: options.body ? JSON.stringify(options.body) : undefined,
+                signal: controller.signal,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                throw new types_1.AnyFastError(data.message || `Gateway request failed with status ${response.status}`, response.status, data.code, data);
+            }
+            return data;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async post(endpoint, body) {
+        return this.makeRequest(endpoint, { method: 'POST', body });
+    }
+    async get(endpoint) {
+        return this.makeRequest(endpoint, { method: 'GET' });
+    }
+    loadFromLocal(filePath) {
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath)) {
+            throw new types_1.AnyFastError(`File not found: ${absolutePath}`);
+        }
+        const ext = path.extname(absolutePath).toLowerCase();
+        const mimeType = MIME_TYPES[ext] || 'application/octet-stream';
+        const buffer = fs.readFileSync(absolutePath);
+        const base64 = buffer.toString('base64');
+        return `data:${mimeType};base64,${base64}`;
+    }
+    static getMimeType(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        return MIME_TYPES[ext] || 'application/octet-stream';
+    }
+}
+exports.AnyFast = AnyFast;

package/dist/file.d.ts

@@ -0,0 +1,8 @@
+import { AnyFast } from './client';
+import { STSTokenResponse } from './types/file';
+export declare class File {
+    private client;
+    constructor(client: AnyFast);
+    getSTSToken(): Promise<STSTokenResponse>;
+    upload(filePath: string): Promise<string>;
+}

package/dist/file.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const client_1 = require("./client");
+const common_1 = require("./types/common");
+const s3_uploader_1 = require("./upload/s3-uploader");
+class File {
+    constructor(client) {
+        this.client = client;
+    }
+    async getSTSToken() {
+        return this.client.makeGatewayRequest('/api/model-verse/sts-token', {
+            method: 'POST',
+        });
+    }
+    async upload(filePath) {
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath)) {
+            throw new common_1.AnyFastError(`File not found: ${absolutePath}`);
+        }
+        const stsResponse = await this.getSTSToken();
+        const { credentials, bucket, region, endpoint, prefix } = stsResponse.data;
+        const fileName = path.basename(absolutePath);
+        const key = `${prefix}${fileName}`;
+        const contentType = client_1.AnyFast.getMimeType(absolutePath);
+        const uploader = new s3_uploader_1.S3Uploader(credentials, bucket, region, endpoint);
+        return uploader.uploadFile(absolutePath, key, contentType);
+    }
+}
+exports.File = File;

package/dist/image.d.ts

@@ -0,0 +1,11 @@
+import { AnyFast } from './client';
+import { ImageGenerationOptions, ImageGenerationResponse, BlockingRunOptions } from './types';
+import { GenerationResponseImpl, TaskStatusImpl } from './task-utils';
+export declare class Image {
+    private client;
+    constructor(client: AnyFast);
+    generate(options: ImageGenerationOptions): Promise<ImageGenerationResponse>;
+    generateAsync(options: ImageGenerationOptions): Promise<GenerationResponseImpl>;
+    queryTask(taskId: string): Promise<TaskStatusImpl>;
+    run(options: ImageGenerationOptions, runOptions?: BlockingRunOptions): Promise<TaskStatusImpl>;
+}

package/dist/image.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Image = void 0;
+const task_utils_1 = require("./task-utils");
+class Image {
+    constructor(client) {
+        this.client = client;
+    }
+    async generate(options) {
+        return this.client.post('/v1/images/generations', options);
+    }
+    async generateAsync(options) {
+        const data = await this.client.post('/v1/images/generations', options);
+        return new task_utils_1.GenerationResponseImpl(data);
+    }
+    async queryTask(taskId) {
+        const data = await this.client.get(`/${taskId}`);
+        return new task_utils_1.TaskStatusImpl(data);
+    }
+    async run(options, runOptions = {}) {
+        const response = await this.generateAsync(options);
+        if (!response.taskId) {
+            throw new Error('No task ID returned from generation request');
+        }
+        return (0, task_utils_1.waitForTaskCompletion)((taskId) => this.queryTask(taskId), response.taskId, runOptions);
+    }
+}
+exports.Image = Image;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { AnyFast } from './client';
+export { Chat } from './chat';
+export { Image } from './image';
+export { Video } from './video';
+export { Asset } from './asset';
+export { File } from './file';
+export { GenerationResponseImpl, TaskStatusImpl } from './task-utils';
+export { parseSSE } from './sse-parser';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSSE = exports.TaskStatusImpl = exports.GenerationResponseImpl = exports.File = exports.Asset = exports.Video = exports.Image = exports.Chat = exports.AnyFast = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "AnyFast", { enumerable: true, get: function () { return client_1.AnyFast; } });
+var chat_1 = require("./chat");
+Object.defineProperty(exports, "Chat", { enumerable: true, get: function () { return chat_1.Chat; } });
+var image_1 = require("./image");
+Object.defineProperty(exports, "Image", { enumerable: true, get: function () { return image_1.Image; } });
+var video_1 = require("./video");
+Object.defineProperty(exports, "Video", { enumerable: true, get: function () { return video_1.Video; } });
+var asset_1 = require("./asset");
+Object.defineProperty(exports, "Asset", { enumerable: true, get: function () { return asset_1.Asset; } });
+var file_1 = require("./file");
+Object.defineProperty(exports, "File", { enumerable: true, get: function () { return file_1.File; } });
+var task_utils_1 = require("./task-utils");
+Object.defineProperty(exports, "GenerationResponseImpl", { enumerable: true, get: function () { return task_utils_1.GenerationResponseImpl; } });
+Object.defineProperty(exports, "TaskStatusImpl", { enumerable: true, get: function () { return task_utils_1.TaskStatusImpl; } });
+var sse_parser_1 = require("./sse-parser");
+Object.defineProperty(exports, "parseSSE", { enumerable: true, get: function () { return sse_parser_1.parseSSE; } });
+__exportStar(require("./types"), exports);

package/dist/sse-parser.d.ts

@@ -0,0 +1,2 @@
+import { SSEEvent } from './types';
+export declare function parseSSE(stream: NodeJS.ReadableStream): AsyncGenerator<SSEEvent>;

package/dist/sse-parser.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSSE = parseSSE;
+async function* parseSSE(stream) {
+    let buffer = '';
+    for await (const chunk of stream) {
+        buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+        const parts = buffer.split('\n\n');
+        buffer = parts.pop() || '';
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            const event = { data: '' };
+            const lines = trimmed.split('\n');
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const value = line.slice(6);
+                    if (value === '[DONE]')
+                        return;
+                    event.data = event.data ? event.data + '\n' + value : value;
+                }
+                else if (line.startsWith('event: ')) {
+                    event.event = line.slice(7);
+                }
+                else if (line.startsWith('id: ')) {
+                    event.id = line.slice(4);
+                }
+                else if (line.startsWith('retry: ')) {
+                    event.retry = parseInt(line.slice(7), 10);
+                }
+                else if (line === 'data:') {
+                    event.data = event.data ? event.data + '\n' : '';
+                }
+            }
+            if (event.data !== undefined) {
+                yield event;
+            }
+        }
+    }
+    // Handle remaining buffer
+    if (buffer.trim()) {
+        const event = { data: '' };
+        const lines = buffer.trim().split('\n');
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                const value = line.slice(6);
+                if (value === '[DONE]')
+                    return;
+                event.data = event.data ? event.data + '\n' + value : value;
+            }
+            else if (line.startsWith('event: ')) {
+                event.event = line.slice(7);
+            }
+            else if (line.startsWith('id: ')) {
+                event.id = line.slice(4);
+            }
+            else if (line.startsWith('retry: ')) {
+                event.retry = parseInt(line.slice(7), 10);
+            }
+        }
+        if (event.data) {
+            yield event;
+        }
+    }
+}

package/dist/task-utils.d.ts

@@ -0,0 +1,24 @@
+import { GenerationResponse, TaskStatus, BlockingRunOptions } from './types/common';
+export declare class GenerationResponseImpl implements GenerationResponse {
+    taskId: string | null;
+    data: any;
+    constructor(data: any);
+}
+export declare class TaskStatusImpl implements TaskStatus {
+    id: string;
+    action: string;
+    status: string;
+    completion: string;
+    created_at: string;
+    updated_at: string;
+    progress: string;
+    fail_reason: string;
+    result: any;
+    constructor(data: any);
+    isCompleted(): boolean;
+    isFailed(): boolean;
+    isProcessing(): boolean;
+    get progressPercent(): number;
+}
+export declare function delay(ms: number): Promise<void>;
+export declare function waitForTaskCompletion(queryFn: (taskId: string) => Promise<TaskStatusImpl>, taskId: string, options?: BlockingRunOptions): Promise<TaskStatusImpl>;

package/dist/task-utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStatusImpl = exports.GenerationResponseImpl = void 0;
+exports.delay = delay;
+exports.waitForTaskCompletion = waitForTaskCompletion;
+class GenerationResponseImpl {
+    constructor(data) {
+        this.data = data;
+        this.taskId = data?.task_id || data?.taskId || null;
+    }
+}
+exports.GenerationResponseImpl = GenerationResponseImpl;
+class TaskStatusImpl {
+    constructor(data) {
+        this.id = data.id || '';
+        this.action = data.action || '';
+        this.status = data.status || '';
+        this.completion = data.completion || '';
+        this.created_at = data.created_at || '';
+        this.updated_at = data.updated_at || '';
+        this.progress = data.progress || '';
+        this.fail_reason = data.fail_reason || '';
+        this.result = data.result || null;
+    }
+    isCompleted() {
+        return this.status === 'SUCCESS';
+    }
+    isFailed() {
+        return this.status === 'FAILURE';
+    }
+    isProcessing() {
+        return ['PENDING', 'PROCESSING', 'RUNNING', 'QUEUED'].includes(this.status);
+    }
+    get progressPercent() {
+        if (!this.progress)
+            return 0;
+        const match = this.progress.match(/(\d+)/);
+        return match ? parseInt(match[1], 10) : 0;
+    }
+}
+exports.TaskStatusImpl = TaskStatusImpl;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForTaskCompletion(queryFn, taskId, options = {}) {
+    const pollInterval = options.pollIntervalMs || 2000;
+    const timeout = options.timeoutMs || 5 * 60 * 1000;
+    const startTime = Date.now();
+    while (true) {
+        const status = await queryFn(taskId);
+        if (status.isCompleted() || status.isFailed()) {
+            return status;
+        }
+        if (Date.now() - startTime > timeout) {
+            throw new Error(`Task ${taskId} timed out after ${timeout}ms`);
+        }
+        await delay(pollInterval);
+    }
+}

package/dist/types/asset.d.ts

@@ -0,0 +1,62 @@
+export interface CreateAssetGroupRequest {
+    model?: string;
+    Name: string;
+}
+export interface AssetGroup {
+    Id: string;
+    Name: string;
+    Title?: string;
+    GroupType?: string;
+    ProjectName?: string;
+    CreateTime?: string;
+    UpdateTime?: string;
+}
+export interface ListAssetGroupsRequest {
+    model?: string;
+    Filter?: {
+        Name?: string;
+        GroupIds?: string[];
+    };
+    PageNumber?: number;
+    PageSize?: number;
+}
+export interface ListAssetGroupsResponse {
+    Items: AssetGroup[];
+    PageNumber: number;
+    PageSize: number;
+    TotalCount: number;
+}
+export interface CreateAssetRequest {
+    model?: string;
+    GroupId: string;
+    Name?: string;
+    AssetType?: string;
+    URL: string;
+}
+export interface Asset {
+    Id: string;
+    Name: string;
+    URL: string;
+    AssetType: string;
+    GroupId: string;
+    Status: string;
+    ProjectName?: string;
+    CreateTime?: string;
+    UpdateTime?: string;
+}
+export interface ListAssetsRequest {
+    model?: string;
+    Filter?: {
+        Name?: string;
+        GroupIds?: string[];
+        GroupType?: string;
+    };
+    PageNumber?: number;
+    PageSize?: number;
+}
+export interface ListAssetsResponse {
+    Items: Asset[];
+    PageNumber: number;
+    PageSize: number;
+    TotalCount: number;
+}

package/dist/types/asset.js

@@ -0,0 +1,3 @@
+"use strict";
+// ---- Asset Group ----
+Object.defineProperty(exports, "__esModule", { value: true });