@promptbook/browser 0.89.0-9 → 0.92.0-3

package/esm/typings/src/formats/csv/utils/isValidCsvString.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Function to check if a string is valid CSV
+ *
+ * @param value The string to check
+ * @returns True if the string is a valid CSV string, false otherwise
+ *
+ * @public exported from `@promptbook/utils`
+ */
+export declare function isValidCsvString(value: string): boolean;

package/esm/typings/src/formats/csv/utils/isValidCsvString.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/typings/src/formats/json/utils/isValidJsonString.d.ts

@@ -1,6 +1,9 @@
 /**
  * Function isValidJsonString will tell you if the string is valid JSON or not
  *
+ * @param value The string to check
+ * @returns True if the string is a valid JSON string, false otherwise
+ *
  * @public exported from `@promptbook/utils`
  */
 export declare function isValidJsonString(value: string): boolean;

package/esm/typings/src/formats/xml/utils/isValidXmlString.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Function to check if a string is valid XML
+ *
+ * @param value
+ * @returns True if the string is a valid XML string, false otherwise
+ *
+ * @public exported from `@promptbook/utils`
+ */
+export declare function isValidXmlString(value: string): boolean;

package/esm/typings/src/formats/xml/utils/isValidXmlString.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/typings/src/llm-providers/_common/filterModels.d.ts

@@ -0,0 +1,15 @@
+import type { AvailableModel } from '../../execution/AvailableModel';
+import type { LlmExecutionTools } from '../../execution/LlmExecutionTools';
+/**
+ * Creates a wrapper around LlmExecutionTools that only exposes models matching the filter function
+ *
+ * @param llmTools The original LLM execution tools to wrap
+ * @param modelFilter Function that determines whether a model should be included
+ * @returns A new LlmExecutionTools instance with filtered models
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare function filterModels<TLlmTools extends LlmExecutionTools>(llmTools: TLlmTools, modelFilter: (model: AvailableModel) => boolean): TLlmTools;
+/**
+ * TODO: !!! [models] Test that this is working
+ */

package/esm/typings/src/llm-providers/_common/register/{$provideEnvFilepath.d.ts → $provideEnvFilename.d.ts}

@@ -2,11 +2,11 @@ import type { string_filename } from '../../../types/typeAliases';
 /**
  * Provides the path to the `.env` file
  *
- * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access .env file
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
  *
  * @private within the repository - for CLI utils
  */
-export declare function $provideEnvFilepath(): Promise<string_filename | null>;
+export declare function $provideEnvFilename(): Promise<string_filename | null>;
 /**
  * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
  */

package/esm/typings/src/llm-providers/_common/register/$provideLlmToolsConfigurationFromEnv.d.ts

@@ -3,7 +3,7 @@ import type { LlmToolsConfiguration } from './LlmToolsConfiguration';
  * @@@
  *
  * @@@ .env
- * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access .env file
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
  *
  * It looks for environment variables:
  * - `process.env.OPENAI_API_KEY`

package/esm/typings/src/llm-providers/_common/register/$provideLlmToolsForTestingAndScriptsAndPlayground.d.ts

@@ -12,7 +12,7 @@ type GetLlmToolsForTestingAndScriptsAndPlaygroundOptions = CreateLlmToolsFromCon
 /**
  * Returns LLM tools for testing purposes
  *
- * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access .env file
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
  *
  * @private within the repository - JUST FOR TESTS, SCRIPTS AND PLAYGROUND
  */

package/esm/typings/src/llm-providers/_common/register/$provideLlmToolsForWizzardOrCli.d.ts

@@ -5,7 +5,14 @@ import type { string_url } from '../../../types/typeAliases';
 import type { really_any } from '../../../utils/organization/really_any';
 import type { CacheLlmToolsOptions } from '../utils/cache/CacheLlmToolsOptions';
 import type { LlmExecutionToolsWithTotalUsage } from '../utils/count-total-usage/LlmExecutionToolsWithTotalUsage';
-type ProvideLlmToolsForWizzardOrCliOptions = Pick<CacheLlmToolsOptions, 'isCacheReloaded'> & ({
+type ProvideLlmToolsForWizzardOrCliOptions = {
+    /**
+     * If true, user will be always prompted for login
+     *
+     * Note: This is used in `ptbk login` command
+     */
+    isLoginloaded?: true;
+} & Pick<CacheLlmToolsOptions, 'isCacheReloaded'> & ({
     /**
      * Use local keys and execute LLMs directly
      */
@@ -29,13 +36,15 @@ type ProvideLlmToolsForWizzardOrCliOptions = Pick<CacheLlmToolsOptions, 'isCache
     readonly appId: string_app_id;
     /**
      *
+     *
+     * Note: When login prompt fails, `process.exit(1)` is called
      */
     loginPrompt(): Promisable<Identification<really_any>>;
 });
 /**
  * Returns LLM tools for CLI
  *
- * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access .env file and also writes this .env file
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file and also writes this .env file
  *
  * @private within the repository - for CLI utils
  */

package/esm/typings/src/llm-providers/_common/register/$provideLlmToolsFromEnv.d.ts

@@ -6,7 +6,7 @@ import type { CreateLlmToolsFromConfigurationOptions } from './createLlmToolsFro
  * Note: This function is not cached, every call creates new instance of `MultipleLlmExecutionTools`
  *
  * @@@ .env
- * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access .env file
+ * Note: `$` is used to indicate that this function is not a pure function - it uses filesystem to access `.env` file
  *
  * It looks for environment variables:
  * - `process.env.OPENAI_API_KEY`

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

@@ -0,0 +1,284 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export type paths = {
+    readonly "/": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * Get server details
+         * @description Returns details about the Promptbook server.
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description Server details in markdown format. */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/login": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        readonly get?: never;
+        readonly put?: never;
+        /**
+         * Login to the server
+         * @description Login to the server and get identification.
+         */
+        readonly post: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody: {
+                readonly content: {
+                    readonly "application/json": {
+                        readonly username?: string;
+                        readonly password?: string;
+                        readonly appId?: string;
+                    };
+                };
+            };
+            readonly responses: {
+                /** @description Successful login */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": {
+                            readonly identification?: Record<string, never>;
+                        };
+                    };
+                };
+            };
+        };
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/books": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * List all books
+         * @description Returns a list of all available books in the collection.
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description A list of books. */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": readonly string[];
+                    };
+                };
+            };
+        };
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly [path: `/books/${string}`]: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * Get book content
+         * @description Returns the content of a specific book.
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path: {
+                    /** @description The ID of the book to retrieve. */
+                    readonly bookId: string;
+                };
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description The content of the book. */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "text/markdown": string;
+                    };
+                };
+                /** @description Book not found. */
+                readonly 404: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/executions": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * List all executions
+         * @description Returns a list of all running execution tasks.
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description A list of execution tasks. */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": readonly Record<string, never>[];
+                    };
+                };
+            };
+        };
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/executions/new": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        readonly get?: never;
+        readonly put?: never;
+        /**
+         * Start a new execution
+         * @description Starts a new execution task for a given pipeline.
+         */
+        readonly post: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody: {
+                readonly content: {
+                    readonly "application/json": {
+                        readonly pipelineUrl?: string;
+                        readonly inputParameters?: Record<string, never>;
+                        readonly identification?: Record<string, never>;
+                    };
+                };
+            };
+            readonly responses: {
+                /** @description The newly created execution task. */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": Record<string, never>;
+                    };
+                };
+                /** @description Invalid input. */
+                readonly 400: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+};
+export type webhooks = Record<string, never>;
+export type components = {
+    schemas: never;
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+};
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;

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'`