@promptbook/wizard 0.100.0-1 → 0.100.0-10

package/esm/typings/src/config.d.ts

@@ -138,9 +138,6 @@ export declare const SMALL_NUMBER = 0.001;
 /**
  * Timeout for the connections in milliseconds
  *
- * Note: Increased from 7 seconds to 30 seconds to accommodate OAuth flows
- * like Facebook login which may require user interaction and redirects
- *
  * @private within the repository - too low-level in comparison with other `MAX_...`
  */
 export declare const CONNECTION_TIMEOUT_MS: number;
@@ -150,13 +147,6 @@ export declare const CONNECTION_TIMEOUT_MS: number;
  * @private within the repository - too low-level in comparison with other `MAX_...`
  */
 export declare const CONNECTION_RETRIES_LIMIT = 5;
-/**
- * Timeout specifically for OAuth authentication flows in milliseconds
- * OAuth flows typically require more time due to user interaction and redirects
- *
- * @private within the repository - too low-level in comparison with other `MAX_...`
- */
-export declare const OAUTH_TIMEOUT_MS: number;
 /**
  * Short time interval to prevent race conditions in milliseconds
  *

package/esm/typings/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.100.0-0`).
+ * It follows semantic versioning (e.g., `0.100.0-9`).
  *
  * @generated
  */

package/esm/typings/src/wizard/wizard.d.ts

@@ -6,6 +6,15 @@ import type { InputParameters } from '../types/typeAliases';
 import type { string_filename } from '../types/typeAliases';
 import type { string_parameter_value } from '../types/typeAliases';
 import type { string_pipeline_url } from '../types/typeAliases';
+/**
+ * Options for wizard methods
+ */
+interface WizardOptions {
+    /**
+     * Whether to enable verbose logging
+     */
+    isVerbose?: boolean;
+}
 /**
  * Wizard for simple usage of the Promptbook
  * Look at `wizard` for more details
@@ -26,7 +35,7 @@ declare class Wizard {
      *
      * Note: This works similar to the `ptbk run` command
      */
-    execute(book: string_pipeline_url | string_filename | PipelineString, inputParameters: InputParameters): Promise<{
+    execute(book: string_pipeline_url | string_filename | PipelineString, inputParameters: InputParameters, options?: WizardOptions): Promise<{
         /**
          * Simple result of the execution
          */
@@ -36,9 +45,9 @@ declare class Wizard {
     /**
      * Provides the tools automatically for the Node.js environment
      *
-     * @param pipelineSource
+     * @param options
      */
-    getExecutionTools(): Promise<Required<Pick<ExecutionTools, 'fs' | 'fetch'>>>;
+    getExecutionTools(options?: WizardOptions): Promise<Required<Pick<ExecutionTools, 'fs' | 'fetch'>>>;
     /**
      * Load book from the source
      *
@@ -49,8 +58,9 @@ declare class Wizard {
      * 3) As a string
      *
      * @param pipelineSource
+     * @param options
      */
-    getCompiledBook(pipelineSource: string_filename | string_pipeline_url | PipelineString): Promise<PipelineJson>;
+    getCompiledBook(pipelineSource: string_filename | string_pipeline_url | PipelineString, options?: WizardOptions): Promise<PipelineJson>;
 }
 /**
  * Wizard for simple usage of the Promptbook

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/wizard",
-    "version": "0.100.0-1",
+    "version": "0.100.0-10",
     "description": "Promptbook: Run AI apps in plain human language across multiple models and platforms",
     "private": false,
     "sideEffects": false,
@@ -95,7 +95,7 @@
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/wizard.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.100.0-1"
+        "@promptbook/core": "0.100.0-10"
     },
     "dependencies": {
         "@ai-sdk/deepseek": "0.1.6",

package/umd/index.umd.js

@@ -49,7 +49,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-1';
+    const PROMPTBOOK_ENGINE_VERSION = '0.100.0-10';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -203,12 +203,9 @@
     /**
      * Timeout for the connections in milliseconds
      *
-     * Note: Increased from 7 seconds to 30 seconds to accommodate OAuth flows
-     * like Facebook login which may require user interaction and redirects
-     *
      * @private within the repository - too low-level in comparison with other `MAX_...`
      */
-    const CONNECTION_TIMEOUT_MS = 30 * 1000;
+    const CONNECTION_TIMEOUT_MS = 7 * 1000;
     // <- TODO: [⏳] Standardize timeouts, Make DEFAULT_TIMEOUT_MS as global constant
     /**
      * How many times to retry the connections
@@ -1400,39 +1397,13 @@
                 transports: ['polling', 'websocket' /*, <- TODO: [🌬] Allow to pass `transports`, add 'webtransport' */],
             });
             // console.log('Connecting to', this.options.remoteServerUrl.href, { socket });
-            let isResolved = false;
             socket.on('connect', () => {
-                if (!isResolved) {
-                    isResolved = true;
-                    resolve(socket);
-                }
-            });
-            socket.on('connect_error', (error) => {
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(new Error(`Failed to connect to ${remoteServerUrl}: ${error.message || error}`));
-                }
-            });
-            socket.on('disconnect', (reason) => {
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(new Error(`Connection to ${remoteServerUrl} was disconnected: ${reason}`));
-                }
+                resolve(socket);
             });
-            // Better timeout handling with more descriptive error message
-            const timeoutId = setTimeout(() => {
-                if (!isResolved) {
-                    isResolved = true;
-                    socket.disconnect();
-                    reject(new Error(`Connection timeout after ${CONNECTION_TIMEOUT_MS / 1000} seconds while connecting to ${remoteServerUrl}. ` +
-                        `This may indicate network issues or the server may be experiencing high load. ` +
-                        `For authentication flows like social login, ensure sufficient time is allowed for user interaction.`));
-                }
+            // TODO: [💩] Better timeout handling
+            setTimeout(() => {
+                reject(new Error(`Timeout while connecting to ${remoteServerUrl}`));
             }, CONNECTION_TIMEOUT_MS);
-            // Clean up timeout if connection succeeds
-            socket.on('connect', () => {
-                clearTimeout(timeoutId);
-            });
         });
     }
 
@@ -1478,33 +1449,8 @@
          * Check the configuration of all execution tools
          */
         async checkConfiguration() {
-            try {
-                const socket = await createRemoteClient(this.options);
-                socket.disconnect();
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    // Provide user-friendly error messages for common connection issues
-                    if (error.message.includes('timeout') || error.message.includes('Timeout')) {
-                        throw new Error(`Connection to Promptbook server timed out. This may happen during authentication flows like Facebook login. ` +
-                            `Please ensure: 1) Server is running at ${this.options.remoteServerUrl}, ` +
-                            `2) Network connection is stable, 3) Authentication process is completed within the timeout period. ` +
-                            `Original error: ${error.message}`);
-                    }
-                    if (error.message.includes('connect') || error.message.includes('ECONNREFUSED')) {
-                        throw new Error(`Cannot connect to Promptbook server at ${this.options.remoteServerUrl}. ` +
-                            `Please check if the server is running and accessible. ` +
-                            `Original error: ${error.message}`);
-                    }
-                    if (error.message.includes('authentication') || error.message.includes('auth')) {
-                        throw new Error(`Authentication failed when connecting to Promptbook server. ` +
-                            `This may happen if social login (like Facebook) was not completed properly. ` +
-                            `Please retry the authentication process. ` +
-                            `Original error: ${error.message}`);
-                    }
-                }
-                throw error; // Re-throw if not a recognized error pattern
-            }
+            const socket = await createRemoteClient(this.options);
+            socket.disconnect();
             // TODO: [main] !!3 Check version of the remote server and compatibility
             // TODO: [🎍] Send checkConfiguration
         }
@@ -6028,7 +5974,23 @@
             .join('/') +
             '.' +
             extension;
-        await promises.mkdir(path.dirname(cacheFilename), { recursive: true });
+        // Note: Try to create cache directory, but don't fail if filesystem has issues
+        try {
+            await promises.mkdir(path.dirname(cacheFilename), { recursive: true });
+        }
+        catch (error) {
+            // Note: If we can't create cache directory, continue without it
+            //       This handles read-only filesystems, permission issues, and missing parent directories
+            if (error instanceof Error && (error.message.includes('EROFS') ||
+                error.message.includes('read-only') ||
+                error.message.includes('EACCES') ||
+                error.message.includes('EPERM') ||
+                error.message.includes('ENOENT'))) ;
+            else {
+                // Re-throw other unexpected errors
+                throw error;
+            }
+        }
         let isDestroyed = true;
         const fileHandler = {
             filename: cacheFilename,
@@ -7792,12 +7754,58 @@
             //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
             const rootDirname = path.join(process.cwd(), DEFAULT_DOWNLOAD_CACHE_DIRNAME);
             const filepath = path.join(...nameToSubfolderPath(hash /* <- TODO: [🎎] Maybe add some SHA256 prefix */), `${basename.substring(0, MAX_FILENAME_LENGTH)}.${mimeTypeToExtension(mimeType)}`);
-            await tools.fs.mkdir(path.dirname(path.join(rootDirname, filepath)), { recursive: true });
+            // Note: Try to create cache directory, but don't fail if filesystem has issues
+            try {
+                await tools.fs.mkdir(path.dirname(path.join(rootDirname, filepath)), { recursive: true });
+            }
+            catch (error) {
+                // Note: If we can't create cache directory, we'll handle it when trying to write the file
+                //       This handles read-only filesystems, permission issues, and missing parent directories
+                if (error instanceof Error && (error.message.includes('EROFS') ||
+                    error.message.includes('read-only') ||
+                    error.message.includes('EACCES') ||
+                    error.message.includes('EPERM') ||
+                    error.message.includes('ENOENT'))) ;
+                else {
+                    // Re-throw other unexpected errors
+                    throw error;
+                }
+            }
             const fileContent = Buffer.from(await response.arrayBuffer());
             if (fileContent.length > DEFAULT_MAX_FILE_SIZE /* <- TODO: Allow to pass different value to remote server */) {
                 throw new LimitReachedError(`File is too large (${Math.round(fileContent.length / 1024 / 1024)}MB). Maximum allowed size is ${Math.round(DEFAULT_MAX_FILE_SIZE / 1024 / 1024)}MB.`);
             }
-            await tools.fs.writeFile(path.join(rootDirname, filepath), fileContent);
+            // Note: Try to cache the downloaded file, but don't fail if the filesystem is read-only
+            try {
+                await tools.fs.writeFile(path.join(rootDirname, filepath), fileContent);
+            }
+            catch (error) {
+                // Note: If we can't write to cache, we'll process the file directly from memory
+                //       This handles read-only filesystems like Vercel
+                if (error instanceof Error && (error.message.includes('EROFS') ||
+                    error.message.includes('read-only') ||
+                    error.message.includes('EACCES') ||
+                    error.message.includes('EPERM') ||
+                    error.message.includes('ENOENT'))) {
+                    // Return a handler that works directly with the downloaded content
+                    return {
+                        source: name,
+                        filename: null,
+                        url,
+                        mimeType,
+                        async asJson() {
+                            return JSON.parse(fileContent.toString('utf-8'));
+                        },
+                        async asText() {
+                            return fileContent.toString('utf-8');
+                        },
+                    };
+                }
+                else {
+                    // Re-throw other unexpected errors
+                    throw error;
+                }
+            }
             // TODO: [💵] Check the file security
             // TODO: [🧹][🧠] Delete the file after the scraping is done
             return makeKnowledgeSourceHandler({ name, knowledgeSourceContent: filepath }, tools, {
@@ -10875,7 +10883,23 @@
                     // <- TODO: [🍀] Make MarkitdownError
                 }
                 // console.log('!!', { result, cacheFilehandler });
-                await this.tools.fs.writeFile(cacheFilehandler.filename, result.text_content);
+                // Note: Try to cache the converted content, but don't fail if the filesystem is read-only
+                try {
+                    await this.tools.fs.writeFile(cacheFilehandler.filename, result.text_content);
+                }
+                catch (error) {
+                    // Note: If we can't write to cache, we'll continue without caching
+                    //       This handles read-only filesystems like Vercel
+                    if (error instanceof Error && (error.message.includes('EROFS') ||
+                        error.message.includes('read-only') ||
+                        error.message.includes('EACCES') ||
+                        error.message.includes('EPERM') ||
+                        error.message.includes('ENOENT'))) ;
+                    else {
+                        // Re-throw other unexpected errors
+                        throw error;
+                    }
+                }
             }
             return cacheFilehandler;
         }
@@ -11163,7 +11187,23 @@
                 extension: 'html',
                 isVerbose,
             });
-            await this.tools.fs.writeFile(cacheFilehandler.filename, html, 'utf-8');
+            // Note: Try to cache the scraped content, but don't fail if the filesystem is read-only
+            try {
+                await this.tools.fs.writeFile(cacheFilehandler.filename, html, 'utf-8');
+            }
+            catch (error) {
+                // Note: If we can't write to cache, we'll continue without caching
+                //       This handles read-only filesystems like Vercel
+                if (error instanceof Error && (error.message.includes('EROFS') ||
+                    error.message.includes('read-only') ||
+                    error.message.includes('EACCES') ||
+                    error.message.includes('EPERM') ||
+                    error.message.includes('ENOENT'))) ;
+                else {
+                    // Re-throw other unexpected errors
+                    throw error;
+                }
+            }
             const markdown = this.showdownConverter.makeMarkdown(html, jsdom$1.window.document);
             return { ...cacheFilehandler, markdown };
         }
@@ -11904,8 +11944,27 @@
                 throw new UnexpectedError(`The "${key}" you want to store in JSON file is not serializable as JSON`);
             }
             const fileContent = stringifyPipelineJson(value);
-            await promises.mkdir(path.dirname(filename), { recursive: true }); // <- [0]
-            await promises.writeFile(filename, fileContent, 'utf-8');
+            // Note: Try to create cache directory and write file, but don't fail if filesystem is read-only or has permission issues
+            try {
+                await promises.mkdir(path.dirname(filename), { recursive: true }); // <- [0]
+                await promises.writeFile(filename, fileContent, 'utf-8');
+            }
+            catch (error) {
+                // Note: If we can't write to cache, silently ignore the error
+                //       This handles read-only filesystems, permission issues, and missing parent directories
+                if (error instanceof Error && (error.message.includes('EROFS') ||
+                    error.message.includes('read-only') ||
+                    error.message.includes('EACCES') ||
+                    error.message.includes('EPERM') ||
+                    error.message.includes('ENOENT'))) {
+                    // Silently ignore filesystem errors - caching is optional
+                    return;
+                }
+                else {
+                    // Re-throw other unexpected errors
+                    throw error;
+                }
+            }
         }
         /**
          * Removes the key/value pair with the given key from the storage, if a key/value pair with the given key exists.
@@ -16775,7 +16834,23 @@
                         ...options,
                     });
                     const compiledFilePath = filePath.replace('.book.md', '.book').replace('.book', '.bookc');
-                    await saveArchive(compiledFilePath, [pipelineJson], fs);
+                    // Note: Try to save the compiled book to disk for caching, but don't fail if the filesystem is read-only
+                    try {
+                        await saveArchive(compiledFilePath, [pipelineJson], fs);
+                    }
+                    catch (error) {
+                        // Note: Ignore filesystem errors (like EROFS on read-only systems like Vercel)
+                        //       The compiled book can still be used even if it can't be cached
+                        if (error instanceof Error && (error.message.includes('EROFS') ||
+                            error.message.includes('read-only') ||
+                            error.message.includes('EACCES') ||
+                            error.message.includes('EPERM') ||
+                            error.message.includes('ENOENT'))) ;
+                        else {
+                            // Re-throw other unexpected errors
+                            throw error;
+                        }
+                    }
                     return pipelineJson;
                 }
             }
@@ -16897,14 +16972,14 @@
          *
          * Note: This works similar to the `ptbk run` command
          */
-        async execute(book, inputParameters) {
+        async execute(book, inputParameters, options = {}) {
             if (!$isRunningInNode()) {
                 throw new EnvironmentMismatchError('Wizard works only in Node.js environment');
             }
             // ▶ Get the tools
-            const tools = await this.getExecutionTools();
+            const tools = await this.getExecutionTools(options);
             // ▶ Get the Pipeline
-            const pipeline = await this.getCompiledBook(book);
+            const pipeline = await this.getCompiledBook(book, options);
             // ▶ Create executor - the function that will execute the Pipeline
             const pipelineExecutor = createPipelineExecutor({ pipeline, tools });
             // 🚀▶ Execute the Pipeline
@@ -16927,15 +17002,16 @@
         /**
          * Provides the tools automatically for the Node.js environment
          *
-         * @param pipelineSource
+         * @param options
          */
-        async getExecutionTools() {
+        async getExecutionTools(options = {}) {
+            var _a;
             if (this.executionTools !== null) {
                 return this.executionTools;
             }
             // TODO: DRY [◽]
             const prepareAndScrapeOptions = {
-                isVerbose: false,
+                isVerbose: (_a = options.isVerbose) !== null && _a !== void 0 ? _a : false,
                 isCacheReloaded: false, // <- TODO: Allow to pass
             }; /* <- TODO: ` satisfies PrepareAndScrapeOptions` */
             const fs = $provideFilesystemForNode();
@@ -16965,9 +17041,10 @@
          * 3) As a string
          *
          * @param pipelineSource
+         * @param options
          */
-        async getCompiledBook(pipelineSource) {
-            const tools = await this.getExecutionTools();
+        async getCompiledBook(pipelineSource, options = {}) {
+            const tools = await this.getExecutionTools(options);
             return /* not await */ $getCompiledBook(tools, pipelineSource);
         }
     }