@heyputer/puter.js 2.1.1 → 2.1.4

package/index.d.ts

@@ -51,11 +51,20 @@ interface AI {
     txt2img(prompt: string, testMode?: boolean): Promise<HTMLImageElement>;
     txt2img(prompt: string, options?: Txt2ImgOptions): Promise<HTMLImageElement>;
 
+    txt2vid(prompt: string, testMode?: boolean): Promise<HTMLVideoElement>;
+    txt2vid(prompt: string, options?: Txt2VidOptions): Promise<HTMLVideoElement>;
+
     txt2speech(text: string): Promise<HTMLAudioElement>;
     txt2speech(text: string, options?: Txt2SpeechOptions): Promise<HTMLAudioElement>;
     txt2speech(text: string, language?: string): Promise<HTMLAudioElement>;
     txt2speech(text: string, language?: string, voice?: string): Promise<HTMLAudioElement>;
     txt2speech(text: string, language?: string, voice?: string, engine?: string): Promise<HTMLAudioElement>;
+
+    speech2txt(source: string | File | Blob): Promise<string | Speech2TxtResult>;
+    speech2txt(source: string | File | Blob, options?: Speech2TxtOptions): Promise<string | Speech2TxtResult>;
+    speech2txt(options: Speech2TxtOptions): Promise<string | Speech2TxtResult>;
+    speech2txt(source: string | File | Blob, testMode?: boolean): Promise<string | Speech2TxtResult>;
+    speech2txt(source: Speech2TxtOptions, testMode?: boolean): Promise<string | Speech2TxtResult>;
 }
 
 type StreamingChatOptions = Omit<ChatOptions, "stream"> & { stream: true };
@@ -108,16 +117,70 @@ interface ToolCall {
 }
 
 interface Txt2ImgOptions {
-    model?: 'gpt-image-1' | 'gemini-2.5-flash-image-preview' | 'dall-e-3';
+    model?: 'gpt-image-1' | 'gpt-image-1-mini' | 'gemini-2.5-flash-image-preview' | 'dall-e-3';
     quality?: 'high' | 'medium' | 'low' | 'hd' | 'standard';
     input_image?: string;
     input_image_mime_type?: string;
 }
 
+interface Txt2VidOptions {
+    prompt?: string;
+    model?: string;
+    duration?: number;
+    seconds?: number;
+    size?: string;
+    resolution?: string;
+    width?: number;
+    height?: number;
+    fps?: number;
+    steps?: number;
+    guidance_scale?: number;
+    seed?: number;
+    output_format?: string;
+    output_quality?: number;
+    negative_prompt?: string;
+    reference_images?: string[];
+    frame_images?: Array<Record<string, unknown>>;
+    metadata?: Record<string, unknown>;
+    provider?: string;
+    service?: string;
+    driver?: string;
+    test_mode?: boolean;
+}
+
 interface Txt2SpeechOptions {
     language?: string;
     voice?: string;
-    engine?: 'standard' | 'neural' | 'generative';
+    engine?: 'standard' | 'neural' | 'long-form' | 'generative' | string;
+    provider?: 'aws-polly' | 'openai' | string;
+    model?: 'gpt-4o-mini-tts' | 'tts-1' | 'tts-1-hd' | string;
+    response_format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm' | string;
+    instructions?: string;
+}
+
+interface Speech2TxtOptions {
+    file?: string | File | Blob;
+    audio?: string | File | Blob;
+    model?: 'gpt-4o-mini-transcribe' | 'gpt-4o-transcribe' | 'gpt-4o-transcribe-diarize' | 'whisper-1' | string;
+    response_format?: 'json' | 'text' | 'diarized_json' | 'srt' | 'verbose_json' | 'vtt' | string;
+    language?: string;
+    prompt?: string;
+    temperature?: number;
+    logprobs?: boolean;
+    timestamp_granularities?: string[];
+    translate?: boolean;
+    stream?: boolean;
+    chunking_strategy?: string;
+    known_speaker_names?: string[];
+    known_speaker_references?: string[];
+    extra_body?: Record<string, unknown>;
+}
+
+interface Speech2TxtResult {
+    text?: string;
+    language?: string;
+    segments?: Array<Record<string, unknown>>;
+    [key: string]: any;
 }
 
 interface ChatResponseChunk {
@@ -146,6 +209,7 @@ interface CreateAppOptions {
     icon?: string;
     maximizeOnStart?: boolean;
     filetypeAssociations?: string[];
+    dedupeName?: boolean;
 }
 
 interface GetAppOptions {
@@ -188,6 +252,8 @@ interface Auth {
     signOut(): void;
     isSignedIn(): boolean;
     getUser(): Promise<User>;
+    getMonthlyUsage(): Promise<MonthlyUsage>;
+    getDetailedAppUsage(appId: string): Promise<DetailedAppUsage>;
 }
 
 interface User {
@@ -196,6 +262,33 @@ interface User {
     email_confirmed: boolean;
 }
 
+interface AllowanceInfo {
+    monthUsageAllowance: number;
+    remaining: number;
+}
+
+interface AppUsage {
+    count: number;
+    total: number;
+}
+
+interface APIUsage {
+    cost: number;
+    count: number;
+    units: number;
+}
+
+interface MonthlyUsage {
+    allowanceInfo: AllowanceInfo;
+    appTotals: Record<string, AppUsage>;
+    usage: Record<string, APIUsage>;
+}
+
+interface DetailedAppUsage {
+    total: number;
+    [key: string]: APIUsage;
+}
+
 // Drivers Module
 interface Drivers {
     call(interface: string, driver: string, method: string, args?: object): Promise<any>;
@@ -214,7 +307,7 @@ interface FileSystem {
     rename(path: string, newName: string): Promise<FSItem>;
     space(): Promise<SpaceInfo>;
     stat(path: string): Promise<FSItem>;
-    upload(items: FileList | File[] | Blob[], dirPath?: string, options?: object): Promise<FSItem[]>;
+    upload(items: FileList | File[] | Blob[], dirPath?: string, options?: UploadOptions): Promise<FSItem[]>;
     write(path: string, data?: string | File | Blob, options?: WriteOptions): Promise<FSItem>;
 }
 
@@ -255,6 +348,12 @@ interface WriteOptions {
     createMissingParents?: boolean;
 }
 
+interface UploadOptions {
+    overwrite?: boolean;
+    dedupeName?: boolean;
+    name?: string;
+}
+
 interface SpaceInfo {
     capacity: number;
     used: number;
@@ -511,4 +610,3 @@ export {
     WorkerExecOptions,
     WorkerInfo, Workers, WriteOptions
 };
-

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heyputer/puter.js",
-    "version": "2.1.1",
+    "version": "2.1.4",
     "description": "Puter.js - A JavaScript library for interacting with Puter services.",
     "main": "src/index.js",
     "types": "index.d.ts",

package/src/modules/AI.js

@@ -1,5 +1,45 @@
 import * as utils from '../lib/utils.js';
 
+const normalizeTTSProvider = (value) => {
+    if (typeof value !== 'string') {
+        return 'aws-polly';
+    }
+    const lower = value.toLowerCase();
+    if (lower === 'openai') return 'openai';
+    if (lower === 'aws' || lower === 'polly' || lower === 'aws-polly') return 'aws-polly';
+    return value;
+};
+
+const TOGETHER_IMAGE_MODEL_PREFIXES = [
+    'black-forest-labs/',
+    'stabilityai/',
+    'togethercomputer/',
+    'playgroundai/',
+    'runwayml/',
+    'lightricks/',
+    'sg161222/',
+    'wavymulder/',
+    'prompthero/',
+];
+
+const TOGETHER_IMAGE_MODEL_KEYWORDS = [
+    'flux',
+    'kling',
+    'sd3',
+    'stable-diffusion',
+    'kolors',
+];
+
+const TOGETHER_VIDEO_MODEL_PREFIXES = [
+    'minimax/',
+    'google/',
+    'bytedance/',
+    'pixverse/',
+    'kwaivgi/',
+    'vidu/',
+    'wan-ai/',
+];
+
 class AI{
     /**
      * Creates a new instance with the given authentication token, API origin, and app ID,
@@ -183,23 +223,43 @@ class AI{
             throw { message: 'Text parameter is required', code: 'text_required' };
         }
 
-        // Validate engine if provided
-        if (options.engine) {
-            const validEngines = ['standard', 'neural', 'long-form', 'generative'];
-            if (!validEngines.includes(options.engine)) {
+        const validEngines = ['standard', 'neural', 'long-form', 'generative'];
+        let provider = normalizeTTSProvider(options.provider);
+
+        if (options.engine && normalizeTTSProvider(options.engine) === 'openai' && !options.provider) {
+            provider = 'openai';
+        }
+
+        if (provider === 'openai') {
+            if (!options.model && typeof options.engine === 'string') {
+                options.model = options.engine;
+            }
+            if (!options.voice) {
+                options.voice = 'alloy';
+            }
+            if (!options.model) {
+                options.model = 'gpt-4o-mini-tts';
+            }
+            if (!options.response_format) {
+                options.response_format = 'mp3';
+            }
+            delete options.engine;
+        } else {
+            provider = 'aws-polly';
+
+            if (options.engine && !validEngines.includes(options.engine)) {
                 throw { message: 'Invalid engine. Must be one of: ' + validEngines.join(', '), code: 'invalid_engine' };
             }
-        }
 
-        // Set default values if not provided
-        if (!options.voice) {
-            options.voice = 'Joanna';
-        }
-        if (!options.engine) {
-            options.engine = 'standard';
-        }
-        if (!options.language) {
-            options.language = 'en-US';
+            if (!options.voice) {
+                options.voice = 'Joanna';
+            }
+            if (!options.engine) {
+                options.engine = 'standard';
+            }
+            if (!options.language) {
+                options.language = 'en-US';
+            }
         }
 
         // check input size
@@ -214,12 +274,28 @@ class AI{
                 break;
             }
         }
-    
-        return await utils.make_driver_method(['source'], 'puter-tts', 'aws-polly', 'synthesize', {
+
+        const driverName = provider === 'openai' ? 'openai-tts' : 'aws-polly';
+
+        return await utils.make_driver_method(['source'], 'puter-tts', driverName, 'synthesize', {
             responseType: 'blob',
             test_mode: testMode ?? false,
             transform: async (result) => {
-                const url = await utils.blob_to_url(result);
+                let url;
+                if (typeof result === 'string') {
+                    url = result;
+                } else if (result instanceof Blob) {
+                    url = await utils.blob_to_url(result);
+                } else if (result instanceof ArrayBuffer) {
+                    const blob = new Blob([result]);
+                    url = await utils.blob_to_url(blob);
+                } else if (result && typeof result === 'object' && typeof result.arrayBuffer === 'function') {
+                    const arrayBuffer = await result.arrayBuffer();
+                    const blob = new Blob([arrayBuffer], { type: result.type || undefined });
+                    url = await utils.blob_to_url(blob);
+                } else {
+                    throw { message: 'Unexpected audio response format', code: 'invalid_audio_response' };
+                }
                 const audio = new Audio(url);
                 audio.toString = () => url;
                 audio.valueOf = () => url;
@@ -228,16 +304,105 @@ class AI{
         }).call(this, options);
     }
 
+    speech2txt = async (...args) => {
+        const MAX_INPUT_SIZE = 25 * 1024 * 1024;
+        if ( !args || !args.length ) {
+            throw ({ message: 'Arguments are required', code: 'arguments_required' });
+        }
+
+        const normalizeSource = async (value) => {
+            if ( value instanceof Blob ) {
+                return await utils.blobToDataUri(value);
+            }
+            return value;
+        };
+
+        let options = {};
+        let testMode = false;
+
+        const primary = args[0];
+        if ( primary && typeof primary === 'object' && !Array.isArray(primary) && !(primary instanceof Blob) ) {
+            options = { ...primary };
+        } else {
+            options.file = await normalizeSource(primary);
+        }
+
+        if ( args[1] && typeof args[1] === 'object' && !Array.isArray(args[1]) && !(args[1] instanceof Blob) ) {
+            options = { ...options, ...args[1] };
+        } else if ( typeof args[1] === 'boolean' ) {
+            testMode = args[1];
+        }
+
+        if ( typeof args[2] === 'boolean' ) {
+            testMode = args[2];
+        }
+
+        if ( options.audio ) {
+            options.file = await normalizeSource(options.audio);
+            delete options.audio;
+        }
+
+        if ( options.file instanceof Blob ) {
+            options.file = await normalizeSource(options.file);
+        }
+
+        if ( !options.file ) {
+            throw { message: 'Audio input is required', code: 'audio_required' };
+        }
+
+        if ( typeof options.file === 'string' && options.file.startsWith('data:') ) {
+            const base64 = options.file.split(',')[1] || '';
+            const padding = base64.endsWith('==') ? 2 : (base64.endsWith('=') ? 1 : 0);
+            const byteLength = Math.floor((base64.length * 3) / 4) - padding;
+            if ( byteLength > MAX_INPUT_SIZE ) {
+                throw { message: 'Input size cannot be larger than 25 MB', code: 'input_too_large' };
+            }
+        }
+
+        const driverMethod = options.translate ? 'translate' : 'transcribe';
+        const driverArgs = { ...options };
+        delete driverArgs.translate;
+
+        const responseFormat = driverArgs.response_format;
+
+        return await utils.make_driver_method([], 'puter-speech2txt', 'openai-speech2txt', driverMethod, {
+            test_mode: testMode,
+            transform: async (result) => {
+                if ( responseFormat === 'text' && result && typeof result === 'object' && typeof result.text === 'string' ) {
+                    return result.text;
+                }
+                return result;
+            },
+        }).call(this, driverArgs);
+    }
+
     // Add new methods for TTS engine management
     txt2speech = Object.assign(this.txt2speech, {
         /**
          * List available TTS engines with pricing information
          * @returns {Promise<Array>} Array of available engines
          */
-        listEngines: async () => {
-            return await utils.make_driver_method(['source'], 'puter-tts', 'aws-polly', 'list_engines', {
+        listEngines: async (options = {}) => {
+            let provider = 'aws-polly';
+            let params = {};
+
+            if (typeof options === 'string') {
+                provider = normalizeTTSProvider(options);
+            } else if (options && typeof options === 'object') {
+                provider = normalizeTTSProvider(options.provider) || provider;
+                params = { ...options };
+                delete params.provider;
+            }
+
+            if (provider === 'openai') {
+                params.provider = 'openai';
+            }
+
+            const driverName = provider === 'openai' ? 'openai-tts' : 'aws-polly';
+
+            return await utils.make_driver_method(['source'], 'puter-tts', driverName, 'list_engines', {
                 responseType: 'text',
-            }).call(this, {});
+            }).call(this, params);
         },
 
         /**
@@ -245,13 +410,26 @@ class AI{
          * @param {string} [engine] - Optional engine filter
          * @returns {Promise<Array>} Array of available voices
          */
-        listVoices: async (engine) => {
-            const params = {};
-            if (engine) {
-                params.engine = engine;
+        listVoices: async (options) => {
+            let provider = 'aws-polly';
+            let params = {};
+
+            if (typeof options === 'string') {
+                params.engine = options;
+            } else if (options && typeof options === 'object') {
+                provider = normalizeTTSProvider(options.provider) || provider;
+                params = { ...options };
+                delete params.provider;
             }
 
-            return utils.make_driver_method(['source'], 'puter-tts', 'aws-polly', 'list_voices', {
+            if (provider === 'openai') {
+                params.provider = 'openai';
+                delete params.engine;
+            }
+
+            const driverName = provider === 'openai' ? 'openai-tts' : 'aws-polly';
+
+            return utils.make_driver_method(['source'], 'puter-tts', driverName, 'list_voices', {
                 responseType: 'text',
             }).call(this, params);
         }
@@ -660,21 +838,155 @@ class AI{
         if (options.model === "nano-banana") 
             options.model = "gemini-2.5-flash-image-preview";
 
-        if (options.model === "gemini-2.5-flash-image-preview")
+        const driverHint = typeof options.driver === 'string' ? options.driver : undefined;
+        const providerRaw = typeof options.provider === 'string'
+            ? options.provider
+            : (typeof options.service === 'string' ? options.service : undefined);
+        const providerHint = typeof providerRaw === 'string' ? providerRaw.toLowerCase() : undefined;
+        const modelLower = typeof options.model === 'string' ? options.model.toLowerCase() : '';
+
+        const looksLikeTogetherModel =
+            typeof options.model === 'string' &&
+            (TOGETHER_IMAGE_MODEL_PREFIXES.some(prefix => modelLower.startsWith(prefix)) ||
+                TOGETHER_IMAGE_MODEL_KEYWORDS.some(keyword => modelLower.includes(keyword)));
+
+        if (driverHint) {
+            AIService = driverHint;
+        } else if (providerHint === 'gemini') {
+            AIService = "gemini-image-generation";
+        } else if (providerHint === 'together' || providerHint === 'together-ai') {
+            AIService = "together-image-generation";
+        } else if (options.model === "gemini-2.5-flash-image-preview") {
             AIService = "gemini-image-generation";
+        } else if (looksLikeTogetherModel) {
+            AIService = "together-image-generation";
+        }
         // Call the original chat.complete method
         return await utils.make_driver_method(['prompt'], 'puter-image-generation', AIService, 'generate', {
             responseType: 'blob',
             test_mode: testMode ?? false,
-            transform: async blob => {
+            transform: async result => {
+                let url;
+                if ( typeof result === 'string' ) {
+                    url = result;
+                } else if ( result instanceof Blob ) {
+                    url = await utils.blob_to_url(result);
+                } else if ( result instanceof ArrayBuffer ) {
+                    const blob = new Blob([result]);
+                    url = await utils.blob_to_url(blob);
+                } else if ( result && typeof result === 'object' && typeof result.arrayBuffer === 'function' ) {
+                    const arrayBuffer = await result.arrayBuffer();
+                    const blob = new Blob([arrayBuffer], { type: result.type || undefined });
+                    url = await utils.blob_to_url(blob);
+                } else {
+                    throw { message: 'Unexpected image response format', code: 'invalid_image_response' };
+                }
                 let img = new Image();
-                img.src = await utils.blob_to_url(blob);
+                img.src = url;
                 img.toString = () => img.src;
                 img.valueOf = () => img.src;
                 return img;
             }
         }).call(this, options);
     }
+
+    txt2vid = async (...args) => {
+        let options = {};
+        let testMode = false;
+
+        if(!args){
+            throw({message: 'Arguments are required', code: 'arguments_required'});
+        }
+
+        if (typeof args[0] === 'string') {
+            options = { prompt: args[0] };
+        }
+
+        if (typeof args[1] === 'boolean' && args[1] === true) {
+            testMode = true;
+        }
+
+        if (typeof args[0] === 'string' && typeof args[1] === "object") {
+            options = args[1];
+            options.prompt = args[0];
+        }
+
+        if (typeof args[0] === 'object') {
+            options = args[0];
+        }
+
+        if (!options.prompt) {
+            throw({message: 'Prompt parameter is required', code: 'prompt_required'});
+        }
+
+        if (!options.model) {
+            options.model = 'sora-2';
+        }
+
+        if (options.duration !== undefined && options.seconds === undefined) {
+            options.seconds = options.duration;
+        }
+
+        let videoService = 'openai-video-generation';
+        const driverHint = typeof options.driver === 'string' ? options.driver : undefined;
+        const driverHintLower = driverHint ? driverHint.toLowerCase() : undefined;
+        const providerRaw = typeof options.provider === 'string'
+            ? options.provider
+            : (typeof options.service === 'string' ? options.service : undefined);
+        const providerHint = typeof providerRaw === 'string' ? providerRaw.toLowerCase() : undefined;
+        const modelLower = typeof options.model === 'string' ? options.model.toLowerCase() : '';
+
+        const looksLikeTogetherVideoModel = typeof options.model === 'string' &&
+            TOGETHER_VIDEO_MODEL_PREFIXES.some(prefix => modelLower.startsWith(prefix));
+
+        if (driverHintLower === 'together' || driverHintLower === 'together-ai') {
+            videoService = 'together-video-generation';
+        } else if (driverHintLower === 'together-video-generation') {
+            videoService = 'together-video-generation';
+        } else if (driverHintLower === 'openai') {
+            videoService = 'openai-video-generation';
+        } else if (driverHint) {
+            videoService = driverHint;
+        } else if (providerHint === 'together' || providerHint === 'together-ai') {
+            videoService = 'together-video-generation';
+        } else if (looksLikeTogetherVideoModel) {
+            videoService = 'together-video-generation';
+        }
+
+        return await utils.make_driver_method(['prompt'], 'puter-video-generation', videoService, 'generate', {
+            responseType: 'blob',
+            test_mode: testMode ?? false,
+            transform: async result => {
+                let sourceUrl = null;
+                let mimeType = null;
+                if (result instanceof Blob) {
+                    sourceUrl = await utils.blob_to_url(result);
+                    mimeType = result.type || 'video/mp4';
+                } else if (typeof result === 'string') {
+                    sourceUrl = result;
+                } else if (result && typeof result === 'object') {
+                    sourceUrl = result.asset_url || result.url || result.href || null;
+                    mimeType = result.mime_type || result.content_type || null;
+                }
+
+                if (!sourceUrl) {
+                    return result;
+                }
+
+                const video = document.createElement('video');
+                video.src = sourceUrl;
+                video.controls = true;
+                video.preload = 'metadata';
+                if (mimeType) {
+                    video.setAttribute('data-mime-type', mimeType);
+                }
+                video.setAttribute('data-source', sourceUrl);
+                video.toString = () => video.src;
+                video.valueOf = () => video.src;
+                return video;
+            }
+        }).call(this, options);
+    }
 }
 
 export default AI;

package/src/modules/Auth.js

@@ -251,6 +251,44 @@ class Auth{
             throw error;
         }
     }
+
+    async getGlobalUsage() {
+        try {
+            const resp = await fetch(`${this.APIOrigin}/metering/globalUsage`, {
+                headers: {
+                    Authorization: `Bearer ${this.authToken}`,
+                },
+            });
+
+            const result = await resp.json();
+
+            // Log the response
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'auth',
+                    operation: 'global_usage',
+                    params: {},
+                    result: result,
+                });
+            }
+
+            return result;
+        } catch( error ) {
+            // Log the error
+            if ( globalThis.puter?.apiCallLogger?.isEnabled() ) {
+                globalThis.puter.apiCallLogger.logRequest({
+                    service: 'auth',
+                    operation: 'global_usage',
+                    params: {},
+                    error: {
+                        message: error.message || error.toString(),
+                        stack: error.stack,
+                    },
+                });
+            }
+            throw error;
+        }
+    }
 }
 
 export default Auth;