@promptbook/vercel 0.89.0-9 → 0.92.0-3

package/esm/typings/src/remote-server/openapi.d.ts

@@ -0,0 +1,187 @@
+/**
+ * @private !!!! Decide how to expose this
+ */
+export declare const openapiJson: {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description: string;
+    };
+    paths: {
+        '/': {
+            get: {
+                summary: string;
+                description: string;
+                responses: {
+                    '200': {
+                        description: string;
+                    };
+                };
+            };
+        };
+        '/login': {
+            post: {
+                summary: string;
+                description: string;
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: string;
+                                properties: {
+                                    username: {
+                                        type: string;
+                                    };
+                                    password: {
+                                        type: string;
+                                    };
+                                    appId: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    '200': {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        identification: {
+                                            type: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/books': {
+            get: {
+                summary: string;
+                description: string;
+                responses: {
+                    '200': {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/books/{bookId}': {
+            get: {
+                summary: string;
+                description: string;
+                parameters: {
+                    in: string;
+                    name: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                    description: string;
+                }[];
+                responses: {
+                    '200': {
+                        description: string;
+                        content: {
+                            'text/markdown': {
+                                schema: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                    '404': {
+                        description: string;
+                    };
+                };
+            };
+        };
+        '/executions': {
+            get: {
+                summary: string;
+                description: string;
+                responses: {
+                    '200': {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/executions/new': {
+            post: {
+                summary: string;
+                description: string;
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: string;
+                                properties: {
+                                    pipelineUrl: {
+                                        type: string;
+                                    };
+                                    inputParameters: {
+                                        type: string;
+                                    };
+                                    identification: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    '200': {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                    '400': {
+                        description: string;
+                    };
+                };
+            };
+        };
+    };
+    components: {};
+    tags: never[];
+};
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/remote-server/socket-types/_subtypes/Identification.d.ts

@@ -1,4 +1,5 @@
 import type { LlmToolsConfiguration } from '../../../llm-providers/_common/register/LlmToolsConfiguration';
+import type { string_ip_address } from '../../../types/typeAliases';
 import type { string_user_id } from '../../../types/typeAliases';
 import type { ApplicationRemoteServerClientOptions } from '../../types/RemoteServerOptions';
 /**
@@ -7,7 +8,12 @@ import type { ApplicationRemoteServerClientOptions } from '../../types/RemoteSer
  * @public exported from `@promptbook/remote-server`
  * @public exported from `@promptbook/remote-client`
  */
-export type Identification<TCustomOptions> = ApplicationModeIdentification<TCustomOptions> | AnonymousModeIdentification;
+export type Identification<TCustomOptions> = (ApplicationModeIdentification<TCustomOptions> | AnonymousModeIdentification) & {
+    /**
+     * Identifier of the IP address of the client
+     */
+    readonly ipAddress?: string_ip_address;
+};
 /**
  * Application mode is situation when you run known and well-defined books with your own api keys
  *

package/esm/typings/src/remote-server/socket-types/_subtypes/identificationToPromptbookToken.d.ts

@@ -0,0 +1,11 @@
+import type { string_promptbook_token } from '../../../types/typeAliases';
+import type { really_unknown } from '../../../utils/organization/really_unknown';
+import type { ApplicationModeIdentification } from './Identification';
+/**
+ * Convert identification to Promptbook token
+ *
+ * @param identification
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function identificationToPromptbookToken(identification: ApplicationModeIdentification<really_unknown>): string_promptbook_token;

package/esm/typings/src/remote-server/socket-types/_subtypes/promptbookTokenToIdentification.d.ts

@@ -0,0 +1,10 @@
+import type { string_promptbook_token } from '../../../types/typeAliases';
+import type { ApplicationModeIdentification } from './Identification';
+/**
+ * Convert Promptbook token to identification
+ *
+ * @param promptbookToken
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function promptbookTokenToIdentification(promptbookToken: string_promptbook_token): ApplicationModeIdentification<undefined>;

package/esm/typings/src/remote-server/startRemoteServer.d.ts

@@ -11,8 +11,7 @@ import type { RemoteServerOptions } from './types/RemoteServerOptions';
  */
 export declare function startRemoteServer<TCustomOptions = undefined>(options: RemoteServerOptions<TCustomOptions>): RemoteServer;
 /**
- * TODO: !! Add CORS and security - probbably via `helmet`
- * TODO: [👩🏾‍🤝‍🧑🏾] Allow to pass custom fetch function here - PromptbookFetch
+ * TODO: [🌡] Add CORS and security - probbably via `helmet`
  * TODO: Split this file into multiple functions - handler for each request
  * TODO: Maybe use `$exportJson`
  * TODO: [🧠][🛍] Maybe not `isAnonymous: boolean` BUT `mode: 'ANONYMOUS'|'COLLECTION'`

package/esm/typings/src/remote-server/types/RemoteServerOptions.d.ts

@@ -3,12 +3,14 @@ import type { Promisable } from 'type-fest';
 import type { PipelineCollection } from '../../collection/PipelineCollection';
 import { AuthenticationError } from '../../errors/AuthenticationError';
 import type { CommonToolsOptions } from '../../execution/CommonToolsOptions';
+import type { ExecutionTools } from '../../execution/ExecutionTools';
 import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
 import type { string_app_id } from '../../types/typeAliases';
 import type { string_email } from '../../types/typeAliases';
 import type { string_password } from '../../types/typeAliases';
-import type { string_uri } from '../../types/typeAliases';
+import type { string_token } from '../../types/typeAliases';
 import type { string_user_id } from '../../types/typeAliases';
+import type { ApplicationModeIdentification } from '../socket-types/_subtypes/Identification';
 import type { Identification } from '../socket-types/_subtypes/Identification';
 /**
  * @@@
@@ -29,14 +31,18 @@ export type RemoteServerOptions<TCustomOptions> = CommonToolsOptions & {
      */
     readonly port: number;
     /**
-     * Root path of the server
+     * Creates execution tools the client
      *
-     * Note: This is useful when you reverse proxy the server without changing the path
+     * This is relevant also in anonymous mode in oposition to `createLlmExecutionTools`
      *
-     * @default '/'
-     * @example '/api/promptbook/'
-     */
-    readonly rootPath?: string_uri;
+     * Note: You can provide only some tools and leave the rest to the default ones also llm tools are created by `createLlmExecutionTools`
+     * Note: This is useful when you want to provide some custom restrictions for example:
+     * - Limit access to certain websites for some users
+     * - Bind user-interface tools to email agent
+     * - Allow / block script execution
+     * - And many more
+     */
+    createExecutionTools?(options: Identification<TCustomOptions>): Promisable<Partial<Omit<ExecutionTools, 'llm'>>>;
 } & ((AnonymousRemoteServerOptions & {
     readonly isApplicationModeAllowed?: false;
 }) | ({
@@ -74,7 +80,7 @@ export type ApplicationRemoteServerOptions<TCustomOptions> = {
     /**
      * Creates llm execution tools for each client
      */
-    createLlmExecutionTools(options: ApplicationRemoteServerClientOptions<TCustomOptions>): Promisable<LlmExecutionTools>;
+    createLlmExecutionTools(options: ApplicationModeIdentification<TCustomOptions>): Promisable<LlmExecutionTools>;
 };
 export type ApplicationRemoteServerClientOptions<TCustomOptions> = {
     /**
@@ -96,7 +102,7 @@ export type ApplicationRemoteServerClientOptions<TCustomOptions> = {
      *
      * Note: This is passed for example to `createLlmExecutionTools`
      */
-    readonly userToken?: string_user_id;
+    readonly userToken?: string_token;
     /**
      * Additional arbitrary options to identify the client or to pass custom metadata
      */

package/esm/typings/src/storage/env-storage/$EnvStorage.d.ts

@@ -0,0 +1,40 @@
+import type { PromptbookStorage } from '../_common/PromptbookStorage';
+/**
+ * Stores data in .env variables
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file and also writes to `process.env`
+ *
+ * @private within the repository - for CLI utils
+ */
+export declare class $EnvStorage<TItem> implements PromptbookStorage<TItem> {
+    private envFilename;
+    private $provideOrCreateEnvFile;
+    private transformKey;
+    /**
+     * Returns the number of key/value pairs currently present in the list associated with the object.
+     */
+    get length(): number;
+    /**
+     * Empties the list associated with the object of all key/value pairs, if there are any.
+     */
+    clear(): void;
+    /**
+     * Returns the current value associated with the given key, or null if the given key does not exist in the list associated with the object.
+     */
+    getItem(key: string): Promise<TItem | null>;
+    /**
+     * Returns the name of the nth key in the list, or null if n is greater than or equal to the number of key/value pairs in the object.
+     */
+    key(index: number): string | null;
+    /**
+     * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
+     */
+    setItem(key: string, value: TItem): Promise<void>;
+    /**
+     * Removes the key/value pair with the given key from the list associated with the object, if a key/value pair with the given key exists.
+     */
+    removeItem(key: string): void;
+}
+/**
+ * TODO: Write file more securely - ensure that there can be no accidental overwriting of existing variables and other content
+ */

package/esm/typings/src/types/typeAliases.d.ts

@@ -325,6 +325,12 @@ export type string_css_selector = string;
  * For example `"https://collboard.com/9SeSQTupmQHwuSrLi"`
  */
 export type string_url = string;
+/**
+ * Semantic helper
+ *
+ * For example `"https://s1.ptbk.io/promptbook"`
+ */
+export type string_promptbook_server_url = string;
 /**
  * Semantic helper
  *
@@ -408,6 +414,13 @@ export type string_host = string;
  * Semantic helper
  */
 export type string_protocol = 'http:' | 'https:';
+/**
+ * Semantic helper
+ *
+ * For example `"192.168.1.1"` (IPv4)
+ * For example `"2001:0db8:85a3:0000:0000:8a2e:0370:7334"` (IPv6)
+ */
+export type string_ip_address = string;
 /**
  * Semantic helper
  *
@@ -521,6 +534,13 @@ export type string_person_profile = string;
  * For example `"MIT"`
  */
 export type string_license = string;
+/**
+ * Semantic helper
+ *
+ * For example `"Pavol Hejný <pavol@ptbk.io> (https://www.pavolhejny.com/)"`
+ * For example `"AI Web, LLC <legal@ptbk.io> (https://www.ptbk.io/)"`
+ */
+export type string_legal_entity = string | string_person_profile | string_title;
 /**
  * Semantic helper for attributes
  *
@@ -570,6 +590,12 @@ export type string_postprocessing_function_name = string;
 export type id = string | number;
 export type task_id = string;
 export type string_token = string;
+/**
+ * Semantic helper
+ *
+ * Made by `identificationToPromptbookToken` exported from `@promptbook/core`
+ */
+export type string_promptbook_token = string_token;
 export type string_license_token = string_token;
 export type string_password = string;
 export type string_ssh_key = string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/vercel",
-    "version": "0.89.0-9",
+    "version": "0.92.0-3",
     "description": "It's time for a paradigm shift. The future of software in plain English, French or Latin",
     "private": false,
     "sideEffects": false,
@@ -43,15 +43,19 @@
         "url": "https://github.com/webgptorg/promptbook/issues"
     },
     "homepage": "https://ptbk.io/",
+    "engines": {
+        "node": ">=16.0.0",
+        "npm": ">=8.0.0"
+    },
     "main": "./umd/index.umd.js",
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/vercel.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.89.0-9"
+        "@promptbook/core": "0.92.0-3"
     },
     "dependencies": {
         "colors": "1.4.0",
-        "crypto": "^1.0.1",
+        "crypto": "1.0.1",
         "spacetrim": "0.11.59"
     }
 }

package/umd/index.umd.js

@@ -23,7 +23,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.89.0-9';
+    const PROMPTBOOK_ENGINE_VERSION = '0.92.0-3';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -60,7 +60,7 @@
         }
     }
     /**
-     * TODO: !!!!!! Add id to all errors
+     * TODO: [🧠][🌂] Add id to all errors
      */
 
     /**
@@ -618,6 +618,7 @@
         infinity: '(infinity; ∞)',
         negativeInfinity: '(negative infinity; -∞)',
         unserializable: '(unserializable value)',
+        circular: '(circular JSON)',
     };
     /**
      * Small number limit
@@ -725,6 +726,54 @@
         }
     }
 
+    /**
+     * This error type indicates that somewhere in the code non-Error object was thrown and it was wrapped into the `WrappedError`
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class WrappedError extends Error {
+        constructor(whatWasThrown) {
+            const tag = `[🤮]`;
+            console.error(tag, whatWasThrown);
+            super(spaceTrim.spaceTrim(`
+                Non-Error object was thrown
+
+                Note: Look for ${tag} in the console for more details
+                Please report issue on ${ADMIN_EMAIL}
+            `));
+            this.name = 'WrappedError';
+            Object.setPrototypeOf(this, WrappedError.prototype);
+        }
+    }
+
+    /**
+     * Helper used in catch blocks to assert that the error is an instance of `Error`
+     *
+     * @param whatWasThrown Any object that was thrown
+     * @returns Nothing if the error is an instance of `Error`
+     * @throws `WrappedError` or `UnexpectedError` if the error is not standard
+     *
+     * @private within the repository
+     */
+    function assertsError(whatWasThrown) {
+        // Case 1: Handle error which was rethrown as `WrappedError`
+        if (whatWasThrown instanceof WrappedError) {
+            const wrappedError = whatWasThrown;
+            throw wrappedError;
+        }
+        // Case 2: Handle unexpected errors
+        if (whatWasThrown instanceof UnexpectedError) {
+            const unexpectedError = whatWasThrown;
+            throw unexpectedError;
+        }
+        // Case 3: Handle standard errors - keep them up to consumer
+        if (whatWasThrown instanceof Error) {
+            return;
+        }
+        // Case 4: Handle non-standard errors - wrap them into `WrappedError` and throw
+        throw new WrappedError(whatWasThrown);
+    }
+
     /**
      * Checks if the value is [🚉] serializable as JSON
      * If not, throws an UnexpectedError with a rich error message and tracking
@@ -816,9 +865,7 @@
                     JSON.stringify(value); // <- TODO: [0]
                 }
                 catch (error) {
-                    if (!(error instanceof Error)) {
-                        throw error;
-                    }
+                    assertsError(error);
                     throw new UnexpectedError(spaceTrim__default["default"]((block) => `
                             \`${name}\` is not serializable
 
@@ -1040,13 +1087,19 @@
                 return value.toISOString();
             }
             else {
-                return JSON.stringify(value);
+                try {
+                    return JSON.stringify(value);
+                }
+                catch (error) {
+                    if (error instanceof TypeError && error.message.includes('circular structure')) {
+                        return VALUE_STRINGS.circular;
+                    }
+                    throw error;
+                }
             }
         }
         catch (error) {
-            if (!(error instanceof Error)) {
-                throw error;
-            }
+            assertsError(error);
             console.error(error);
             return VALUE_STRINGS.unserializable;
         }