anyfast 0.0.1

package/dist/types/chat.d.ts

@@ -0,0 +1,192 @@
+export interface ChatCompletionRequest {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string | any[];
+    }>;
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+    n?: number;
+    response_format?: {
+        type: string;
+    };
+    tools?: any[];
+    tool_choice?: any;
+    [key: string]: any;
+}
+export interface ChatCompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: string;
+            content: string | null;
+            tool_calls?: any[];
+        };
+        finish_reason: string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface ChatCompletionChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+            tool_calls?: any[];
+        };
+        finish_reason: string | null;
+    }>;
+}
+export interface AnthropicMessagesRequest {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string | any[];
+    }>;
+    max_tokens: number;
+    stream?: boolean;
+    system?: string | any[];
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    stop_sequences?: string[];
+    tools?: any[];
+    tool_choice?: any;
+    thinking?: {
+        type: string;
+        budget_tokens?: number;
+    };
+    metadata?: {
+        user_id?: string;
+    };
+    [key: string]: any;
+}
+export interface AnthropicMessagesResponse {
+    id: string;
+    type: string;
+    role: string;
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: any;
+    }>;
+    model: string;
+    stop_reason: string | null;
+    stop_sequence: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+    };
+}
+export interface ResponsesRequest {
+    model: string;
+    input: string | any[];
+    stream?: boolean;
+    temperature?: number;
+    top_p?: number;
+    max_output_tokens?: number;
+    reasoning?: {
+        effort: string;
+    };
+    [key: string]: any;
+}
+export interface ResponsesResponse {
+    id: string;
+    object: string;
+    created_at: number;
+    completed_at?: number;
+    model: string;
+    status: string;
+    output: Array<{
+        type: string;
+        role?: string;
+        status?: string;
+        content?: Array<{
+            type: string;
+            text: string;
+        }>;
+        summary?: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface GeminiGenerateContentRequest {
+    contents: Array<{
+        role?: string;
+        parts: Array<{
+            text?: string;
+            inlineData?: {
+                mimeType: string;
+                data: string;
+            };
+        }>;
+    }>;
+    generationConfig?: {
+        temperature?: number;
+        topP?: number;
+        topK?: number;
+        maxOutputTokens?: number;
+        stopSequences?: string[];
+        responseMimeType?: string;
+        responseSchema?: any;
+    };
+    systemInstruction?: {
+        parts: Array<{
+            text: string;
+        }>;
+    };
+    tools?: any[];
+    toolConfig?: any;
+    safetySettings?: any[];
+    [key: string]: any;
+}
+export interface GeminiGenerateContentResponse {
+    candidates: Array<{
+        content: {
+            parts: Array<{
+                text?: string;
+                [key: string]: any;
+            }>;
+            role: string;
+        };
+        finishReason: string;
+        index: number;
+        safetyRatings?: any[];
+    }>;
+    usageMetadata?: {
+        promptTokenCount: number;
+        candidatesTokenCount: number;
+        totalTokenCount: number;
+    };
+}
+export interface SSEEvent {
+    event?: string;
+    data: string;
+    id?: string;
+    retry?: number;
+}

package/dist/types/chat.js

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

package/dist/types/common.d.ts

@@ -0,0 +1,40 @@
+export interface AnyFastOptions {
+    apiKey?: string;
+    baseURL?: string;
+    gatewayURL?: string;
+    timeout?: number;
+}
+export declare class AnyFastError extends Error {
+    status?: number;
+    code?: string;
+    data?: any;
+    constructor(message: string, status?: number, code?: string, data?: any);
+}
+export interface GenerationResponse {
+    taskId: string | null;
+    data: any;
+}
+export interface TaskStatus {
+    id: string;
+    action: string;
+    status: string;
+    completion: string;
+    created_at: string;
+    updated_at: string;
+    progress: string;
+    fail_reason: string;
+    result: any;
+    isCompleted(): boolean;
+    isFailed(): boolean;
+    isProcessing(): boolean;
+}
+export interface BlockingRunOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+}
+export interface TaskGenerationOptions {
+    model: string;
+    prompt: string;
+    image?: string;
+    [key: string]: any;
+}

package/dist/types/common.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyFastError = void 0;
+class AnyFastError extends Error {
+    constructor(message, status, code, data) {
+        super(message);
+        this.name = 'AnyFastError';
+        this.status = status;
+        this.code = code;
+        this.data = data;
+    }
+}
+exports.AnyFastError = AnyFastError;

package/dist/types/file.d.ts

@@ -0,0 +1,22 @@
+export interface FileUploadConfig {
+    bucket: string;
+    region: string;
+    endpoint?: string;
+}
+export interface STSCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string;
+}
+export interface STSTokenData {
+    credentials: STSCredentials;
+    bucket: string;
+    region: string;
+    endpoint?: string;
+    prefix: string;
+}
+export interface STSTokenResponse {
+    code: number;
+    data: STSTokenData;
+    message: string;
+}

package/dist/types/file.js

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

package/dist/types/image.d.ts

@@ -0,0 +1,20 @@
+export interface ImageGenerationOptions {
+    model: string;
+    prompt: string;
+    n?: number;
+    size?: string;
+    quality?: string;
+    response_format?: string;
+    output_format?: string;
+    seed?: number;
+    image?: string | string[];
+    [key: string]: any;
+}
+export interface ImageGenerationResponse {
+    created: number;
+    data: Array<{
+        url?: string;
+        b64_json?: string;
+        revised_prompt?: string;
+    }>;
+}

package/dist/types/image.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './chat';
+export * from './image';
+export * from './video';
+export * from './asset';
+export * from './file';

package/dist/types/index.js

@@ -0,0 +1,22 @@
+"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 });
+__exportStar(require("./common"), exports);
+__exportStar(require("./chat"), exports);
+__exportStar(require("./image"), exports);
+__exportStar(require("./video"), exports);
+__exportStar(require("./asset"), exports);
+__exportStar(require("./file"), exports);

package/dist/types/video.d.ts

@@ -0,0 +1,95 @@
+export interface SeedanceVideoOptions {
+    model: string;
+    content: Array<{
+        type: string;
+        text?: string;
+        image_url?: {
+            url: string;
+        };
+        video_url?: {
+            url: string;
+        };
+        audio_url?: {
+            url: string;
+        };
+        role?: string;
+    }>;
+    generate_audio?: boolean;
+    resolution?: string;
+    ratio?: string;
+    duration?: number;
+    watermark?: boolean;
+    [key: string]: any;
+}
+export interface KlingText2VideoOptions {
+    model_name: string;
+    prompt: string;
+    negative_prompt?: string;
+    mode?: 'std' | 'pro';
+    duration?: string;
+    aspect_ratio?: string;
+    cfg_scale?: number;
+    multi_shot?: boolean;
+    shot_type?: string;
+    multi_prompt?: Array<{
+        index: number;
+        prompt: string;
+        duration: string;
+    }>;
+    sound?: 'on' | 'off';
+    camera_control?: any;
+    watermark_info?: {
+        enabled: boolean;
+    };
+    callback_url?: string;
+    external_task_id?: string;
+    [key: string]: any;
+}
+export interface KlingImage2VideoOptions {
+    model_name: string;
+    image?: string;
+    image_tail?: string;
+    prompt?: string;
+    negative_prompt?: string;
+    mode?: 'std' | 'pro';
+    duration?: string;
+    cfg_scale?: number;
+    multi_shot?: boolean;
+    shot_type?: string;
+    multi_prompt?: Array<{
+        index: number;
+        prompt: string;
+        duration: string;
+    }>;
+    element_list?: Array<{
+        element_id: string;
+    }>;
+    sound?: 'on' | 'off';
+    camera_control?: any;
+    static_mask?: string;
+    dynamic_masks?: any[];
+    watermark_info?: {
+        enabled: boolean;
+    };
+    callback_url?: string;
+    external_task_id?: string;
+    [key: string]: any;
+}
+export interface KlingMultiImage2VideoOptions {
+    model_name: string;
+    image_list: Array<{
+        image: string;
+    }>;
+    prompt: string;
+    negative_prompt?: string;
+    mode?: 'std' | 'pro';
+    duration?: string;
+    aspect_ratio?: string;
+    watermark_info?: {
+        enabled: boolean;
+    };
+    callback_url?: string;
+    external_task_id?: string;
+    [key: string]: any;
+}
+export type KlingAction = 'text2video' | 'image2video' | 'multi-image2video' | 'omni-video' | 'lip-sync';

package/dist/types/video.js

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

package/dist/types.d.ts

@@ -0,0 +1 @@
+export * from './types/index';

package/dist/types.js

@@ -0,0 +1,18 @@
+"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 });
+// Re-export all types from the types directory for backwards compatibility
+__exportStar(require("./types/index"), exports);

package/dist/upload/s3-uploader.d.ts

@@ -0,0 +1,10 @@
+import { STSCredentials } from '../types/file';
+export declare class S3Uploader {
+    private s3Client;
+    private bucket;
+    constructor(credentials: STSCredentials, bucket: string, region: string, endpoint?: string);
+    uploadFile(filePath: string, key: string, contentType: string): Promise<string>;
+    private simpleUpload;
+    private multipartUpload;
+    private getObjectUrl;
+}

package/dist/upload/s3-uploader.js

@@ -0,0 +1,123 @@
+"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.S3Uploader = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const fs = __importStar(require("fs"));
+const MULTIPART_THRESHOLD = 8 * 1024 * 1024; // 8MB
+class S3Uploader {
+    constructor(credentials, bucket, region, endpoint) {
+        this.bucket = bucket;
+        this.s3Client = new client_s3_1.S3Client({
+            region,
+            credentials: {
+                accessKeyId: credentials.accessKeyId,
+                secretAccessKey: credentials.secretAccessKey,
+                sessionToken: credentials.sessionToken,
+            },
+            ...(endpoint ? { endpoint } : {}),
+        });
+    }
+    async uploadFile(filePath, key, contentType) {
+        const stats = fs.statSync(filePath);
+        if (stats.size > MULTIPART_THRESHOLD) {
+            return this.multipartUpload(filePath, key, contentType);
+        }
+        return this.simpleUpload(filePath, key, contentType);
+    }
+    async simpleUpload(filePath, key, contentType) {
+        const fileContent = fs.readFileSync(filePath);
+        await this.s3Client.send(new client_s3_1.PutObjectCommand({
+            Bucket: this.bucket,
+            Key: key,
+            Body: fileContent,
+            ContentType: contentType,
+        }));
+        return this.getObjectUrl(key);
+    }
+    async multipartUpload(filePath, key, contentType) {
+        const createResponse = await this.s3Client.send(new client_s3_1.CreateMultipartUploadCommand({
+            Bucket: this.bucket,
+            Key: key,
+            ContentType: contentType,
+        }));
+        const uploadId = createResponse.UploadId;
+        const fileSize = fs.statSync(filePath).size;
+        const parts = [];
+        try {
+            let partNumber = 1;
+            let offset = 0;
+            while (offset < fileSize) {
+                const chunkSize = Math.min(MULTIPART_THRESHOLD, fileSize - offset);
+                const buffer = Buffer.alloc(chunkSize);
+                const fd = fs.openSync(filePath, 'r');
+                fs.readSync(fd, buffer, 0, chunkSize, offset);
+                fs.closeSync(fd);
+                const uploadPartResponse = await this.s3Client.send(new client_s3_1.UploadPartCommand({
+                    Bucket: this.bucket,
+                    Key: key,
+                    UploadId: uploadId,
+                    PartNumber: partNumber,
+                    Body: buffer,
+                }));
+                parts.push({
+                    ETag: uploadPartResponse.ETag,
+                    PartNumber: partNumber,
+                });
+                partNumber++;
+                offset += chunkSize;
+            }
+            await this.s3Client.send(new client_s3_1.CompleteMultipartUploadCommand({
+                Bucket: this.bucket,
+                Key: key,
+                UploadId: uploadId,
+                MultipartUpload: { Parts: parts },
+            }));
+            return this.getObjectUrl(key);
+        }
+        catch (error) {
+            await this.s3Client.send(new client_s3_1.AbortMultipartUploadCommand({
+                Bucket: this.bucket,
+                Key: key,
+                UploadId: uploadId,
+            }));
+            throw error;
+        }
+    }
+    getObjectUrl(key) {
+        return `https://${this.bucket}.s3.amazonaws.com/${key}`;
+    }
+}
+exports.S3Uploader = S3Uploader;

package/dist/video.d.ts

@@ -0,0 +1,17 @@
+import { AnyFast } from './client';
+import { BlockingRunOptions, SeedanceVideoOptions, KlingText2VideoOptions, KlingImage2VideoOptions, KlingMultiImage2VideoOptions, KlingAction } from './types';
+import { GenerationResponseImpl, TaskStatusImpl } from './task-utils';
+export declare class Video {
+    private client;
+    constructor(client: AnyFast);
+    generateAsync(options: SeedanceVideoOptions): Promise<GenerationResponseImpl>;
+    queryTask(taskId: string): Promise<TaskStatusImpl>;
+    run(options: SeedanceVideoOptions, runOptions?: BlockingRunOptions): Promise<TaskStatusImpl>;
+    klingText2Video(options: KlingText2VideoOptions): Promise<GenerationResponseImpl>;
+    klingImage2Video(options: KlingImage2VideoOptions): Promise<GenerationResponseImpl>;
+    klingMultiImage2Video(options: KlingMultiImage2VideoOptions): Promise<GenerationResponseImpl>;
+    klingQueryTask(action: KlingAction, taskId: string): Promise<TaskStatusImpl>;
+    runKlingText2Video(options: KlingText2VideoOptions, runOptions?: BlockingRunOptions): Promise<TaskStatusImpl>;
+    runKlingImage2Video(options: KlingImage2VideoOptions, runOptions?: BlockingRunOptions): Promise<TaskStatusImpl>;
+    runKlingMultiImage2Video(options: KlingMultiImage2VideoOptions, runOptions?: BlockingRunOptions): Promise<TaskStatusImpl>;
+}

package/dist/video.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Video = void 0;
+const task_utils_1 = require("./task-utils");
+class Video {
+    constructor(client) {
+        this.client = client;
+    }
+    // ---- Seedance ----
+    async generateAsync(options) {
+        const data = await this.client.post('/v1/video/generations', options);
+        return new task_utils_1.GenerationResponseImpl(data);
+    }
+    async queryTask(taskId) {
+        const data = await this.client.get(`/v1/video/generations/${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);
+    }
+    // ---- Kling ----
+    async klingText2Video(options) {
+        const data = await this.client.post('/kling/v1/videos/text2video', options);
+        return new task_utils_1.GenerationResponseImpl(data);
+    }
+    async klingImage2Video(options) {
+        const data = await this.client.post('/kling/v1/videos/image2video', options);
+        return new task_utils_1.GenerationResponseImpl(data);
+    }
+    async klingMultiImage2Video(options) {
+        const data = await this.client.post('/kling/v1/videos/multi-image2video', options);
+        return new task_utils_1.GenerationResponseImpl(data);
+    }
+    async klingQueryTask(action, taskId) {
+        const data = await this.client.get(`/kling/v1/videos/${action}/${taskId}`);
+        return new task_utils_1.TaskStatusImpl(data);
+    }
+    async runKlingText2Video(options, runOptions = {}) {
+        const response = await this.klingText2Video(options);
+        if (!response.taskId) {
+            throw new Error('No task ID returned from Kling text2video request');
+        }
+        return (0, task_utils_1.waitForTaskCompletion)((taskId) => this.klingQueryTask('text2video', taskId), response.taskId, runOptions);
+    }
+    async runKlingImage2Video(options, runOptions = {}) {
+        const response = await this.klingImage2Video(options);
+        if (!response.taskId) {
+            throw new Error('No task ID returned from Kling image2video request');
+        }
+        return (0, task_utils_1.waitForTaskCompletion)((taskId) => this.klingQueryTask('image2video', taskId), response.taskId, runOptions);
+    }
+    async runKlingMultiImage2Video(options, runOptions = {}) {
+        const response = await this.klingMultiImage2Video(options);
+        if (!response.taskId) {
+            throw new Error('No task ID returned from Kling multi-image2video request');
+        }
+        return (0, task_utils_1.waitForTaskCompletion)((taskId) => this.klingQueryTask('multi-image2video', taskId), response.taskId, runOptions);
+    }
+}
+exports.Video = Video;