@heyputer/puter.js 2.1.4 → 2.1.6

package/index.d.ts

@@ -9,7 +9,7 @@ declare global {
 declare class Puter {
     // Properties
     appID: string;
-    env: 'app' | 'web' | 'gui';
+    env: 'app' | 'web' | 'gui' | 'nodejs' | 'service-worker';
 
     // Utility methods
     print(text: string, options?: { code?: boolean }): void;
@@ -47,6 +47,9 @@ interface AI {
     chat(messages: ChatMessage[], testMode?: boolean, options?: NonStreamingChatOptions): Promise<ChatResponse>;
 
     img2txt(image: string | File | Blob, testMode?: boolean): Promise<string>;
+    img2txt(image: string | File | Blob, options?: Img2TxtOptions): Promise<string>;
+    img2txt(image: string | File | Blob, testMode?: boolean, options?: Img2TxtOptions): Promise<string>;
+    img2txt(options: Img2TxtOptions): Promise<string>;
 
     txt2img(prompt: string, testMode?: boolean): Promise<HTMLImageElement>;
     txt2img(prompt: string, options?: Txt2ImgOptions): Promise<HTMLImageElement>;
@@ -75,6 +78,16 @@ interface ChatOptions {
     stream?: boolean;
     max_tokens?: number;
     temperature?: number;
+    reasoning?: {
+        effort?: 'none' | 'low' | 'medium' | 'high' | 'minimal';
+        [key: string]: unknown;
+    };
+    reasoning_effort?: 'none' | 'low' | 'medium' | 'high' | 'minimal';
+    text?: {
+        verbosity?: 'low' | 'medium' | 'high';
+        [key: string]: unknown;
+    };
+    verbosity?: 'low' | 'medium' | 'high';
     tools?: ToolDefinition[];
 }
 
@@ -148,6 +161,19 @@ interface Txt2VidOptions {
     test_mode?: boolean;
 }
 
+interface Img2TxtOptions {
+    source?: string | File | Blob;
+    provider?: 'aws-textract' | 'mistral';
+    model?: string;
+    pages?: number[];
+    includeImageBase64?: boolean;
+    imageLimit?: number;
+    imageMinSize?: number;
+    bboxAnnotationFormat?: Record<string, unknown>;
+    documentAnnotationFormat?: Record<string, unknown>;
+    testMode?: boolean;
+}
+
 interface Txt2SpeechOptions {
     language?: string;
     voice?: string;

package/package.json

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

package/src/index.js

@@ -785,6 +785,43 @@ export const puter =  puterInit();
 export default puter;
 globalThis.puter = puter;
 
+puter.tools = [];
+/**
+ * @type {{messageTarget: Window}}
+ */
+const puterParent = puter.ui.parentApp();
+globalThis.puterParent = puterParent;
+if (puterParent) {
+    console.log("I have a parent, registering tools")
+    puterParent.on('message', async (event) => {
+        console.log("Got tool req ", event)
+        if (event.$ === "requestTools") {
+            console.log("Responding with tools")
+            puterParent.postMessage({
+                $: "providedTools",
+                tools: JSON.parse(JSON.stringify(puter.tools))
+            });
+        }
+
+        if (event.$ === "executeTool") {
+            console.log("xecuting tools")
+            /**
+             * Puter tools format
+             * @type {[{exec: Function, function: {description: string, name: string, parameters: {properties: any, required: Array<string>}, type: string}}]}
+             */
+            const [tool] = puter.tools.filter(e=>e.function.name === event.toolName);
+
+            const response = await tool.exec(event.parameters);
+            puterParent.postMessage({
+                $: "toolResponse",
+                response,
+                tag: event.tag,
+            });
+        }
+    });
+    puterParent.postMessage({$: "ready"});
+}
+
 globalThis.addEventListener && globalThis.addEventListener('message', async (event) => {
     // if the message is not from Puter, then ignore it
     if ( event.origin !== puter.defaultGUIOrigin ) return;

package/src/modules/AI.js

@@ -118,48 +118,100 @@ class AI{
     }
     
     img2txt = async (...args) => {
-        let MAX_INPUT_SIZE = 10 * 1024 * 1024;
+        const MAX_INPUT_SIZE = 10 * 1024 * 1024;
+        if (!args || args.length === 0) {
+            throw { message: 'Arguments are required', code: 'arguments_required' };
+        }
+
+        const isBlobLike = (value) => {
+            if (typeof Blob === 'undefined') return false;
+            return value instanceof Blob || (typeof File !== 'undefined' && value instanceof File);
+        };
+        const isPlainObject = (value) => value && typeof value === 'object' && !Array.isArray(value) && !isBlobLike(value);
+        const normalizeProvider = (value) => {
+            if (!value) return 'aws-textract';
+            const normalized = String(value).toLowerCase();
+            if (['aws', 'textract', 'aws-textract'].includes(normalized)) return 'aws-textract';
+            if (['mistral', 'mistral-ocr'].includes(normalized)) return 'mistral';
+            return 'aws-textract';
+        };
+
         let options = {};
+        if (isPlainObject(args[0])) {
+            options = { ...args[0] };
+        } else {
+            options.source = args[0];
+        }
+
         let testMode = false;
+        for (let i = 1; i < args.length; i++) {
+            const value = args[i];
+            if (typeof value === 'boolean') {
+                testMode = testMode || value;
+            } else if (isPlainObject(value)) {
+                options = { ...options, ...value };
+            }
+        }
 
-        // Check that the argument is not undefined or null
-        if(!args){
-            throw({message: 'Arguments are required', code: 'arguments_required'});
+        if (typeof options.testMode === 'boolean') {
+            testMode = options.testMode;
         }
 
-        // if argument is string transform it to the object that the API expects
-        if (typeof args[0] === 'string' || args[0] instanceof Blob) {
-            options.source = args[0];
+        const provider = normalizeProvider(options.provider);
+        delete options.provider;
+        delete options.testMode;
+
+        if (!options.source) {
+            throw { message: 'Source is required', code: 'source_required' };
         }
 
-        // if input is a blob, transform it to a data URI
-        if (args[0].source instanceof Blob) {
-            options.source = await utils.blobToDataUri(args[0].source);
+        if (isBlobLike(options.source)) {
+            options.source = await utils.blobToDataUri(options.source);
+        } else if (options.source?.source && isBlobLike(options.source.source)) {
+            // Support shape { source: Blob }
+            options.source = await utils.blobToDataUri(options.source.source);
         }
 
-        // check input size
-        if (options.source.length > this.MAX_INPUT_SIZE) {
+        if (typeof options.source === 'string' &&
+            options.source.startsWith('data:') &&
+            options.source.length > MAX_INPUT_SIZE) {
             throw { message: 'Input size cannot be larger than ' + MAX_INPUT_SIZE, code: 'input_too_large' };
         }
 
-        // determine if test mode is enabled
-        if (typeof args[1] === 'boolean' && args[1] === true ||
-            typeof args[2] === 'boolean' && args[2] === true ||
-            typeof args[3] === 'boolean' && args[3] === true) {
-            testMode = true;
-        }
-    
-        return await utils.make_driver_method(['source'], 'puter-ocr', 'aws-textract', 'recognize', {
-            test_mode: testMode ?? false,
-            transform: async (result) => {
+        const toText = (result) => {
+            if (!result) return '';
+            if (Array.isArray(result.blocks) && result.blocks.length) {
                 let str = '';
-                for (let i = 0; i < result?.blocks?.length; i++) {
-                    if("text/textract:LINE" === result.blocks[i].type)
-                        str += result.blocks[i].text + "\n";
+                for (const block of result.blocks) {
+                    if (typeof block?.text !== 'string') continue;
+                    if (!block.type || block.type === 'text/textract:LINE' || block.type.startsWith('text/')) {
+                        str += block.text + '\n';
+                    }
                 }
-                return str;
+                if (str.trim()) return str;
             }
-        }).call(this, options);
+            if (Array.isArray(result.pages) && result.pages.length) {
+                const markdown = result.pages
+                    .map(page => (page?.markdown || '').trim())
+                    .filter(Boolean)
+                    .join('\n\n');
+                if (markdown.trim()) return markdown;
+            }
+            if (typeof result.document_annotation === 'string') {
+                return result.document_annotation;
+            }
+            if (typeof result.text === 'string') {
+                return result.text;
+            }
+            return '';
+        };
+
+        const driverCall = utils.make_driver_method(['source'], 'puter-ocr', provider, 'recognize', {
+            test_mode: testMode ?? false,
+            transform: async (result) => toText(result),
+        });
+
+        return await driverCall.call(this, options);
     }
 
     txt2speech = async (...args) => {
@@ -743,6 +795,9 @@ class AI{
         else if ( requestParams.model.startsWith('openrouter:') ) {
             driver = 'openrouter';
         }
+        else if ( requestParams.model.startsWith('ollama:') ) {
+            driver = 'ollama';
+        }
 
         // stream flag from userParams
         if(userParams.stream !== undefined && typeof userParams.stream === 'boolean'){
@@ -754,7 +809,7 @@ class AI{
         }
 
         // Additional parameters to pass from userParams to requestParams
-        const PARAMS_TO_PASS = ['tools', 'response'];
+        const PARAMS_TO_PASS = ['tools', 'response', 'reasoning', 'reasoning_effort', 'text', 'verbosity'];
         for ( const name of PARAMS_TO_PASS ) {
             if ( userParams[name] ) {
                 requestParams[name] = userParams[name];