@promptbook/node 0.92.0-5 → 0.92.0-7

package/esm/typings/src/_packages/core.index.d.ts

@@ -91,6 +91,8 @@ import { filterModels } from '../llm-providers/_common/filterModels';
 import { $llmToolsMetadataRegister } from '../llm-providers/_common/register/$llmToolsMetadataRegister';
 import { $llmToolsRegister } from '../llm-providers/_common/register/$llmToolsRegister';
 import { createLlmToolsFromConfiguration } from '../llm-providers/_common/register/createLlmToolsFromConfiguration';
+import { MODEL_TRUST_LEVEL } from '../llm-providers/_common/register/LlmToolsMetadata';
+import { MODEL_ORDER } from '../llm-providers/_common/register/LlmToolsMetadata';
 import { cacheLlmTools } from '../llm-providers/_common/utils/cache/cacheLlmTools';
 import { countUsage } from '../llm-providers/_common/utils/count-total-usage/countUsage';
 import { limitTotalUsage } from '../llm-providers/_common/utils/count-total-usage/limitTotalUsage';
@@ -230,6 +232,8 @@ export { filterModels };
 export { $llmToolsMetadataRegister };
 export { $llmToolsRegister };
 export { createLlmToolsFromConfiguration };
+export { MODEL_TRUST_LEVEL };
+export { MODEL_ORDER };
 export { cacheLlmTools };
 export { countUsage };
 export { limitTotalUsage };

package/esm/typings/src/_packages/utils.index.d.ts

@@ -7,6 +7,7 @@ import { serializeError } from '../errors/utils/serializeError';
 import { forEachAsync } from '../execution/utils/forEachAsync';
 import { isValidCsvString } from '../formats/csv/utils/isValidCsvString';
 import { isValidJsonString } from '../formats/json/utils/isValidJsonString';
+import { jsonParse } from '../formats/json/utils/jsonParse';
 import { isValidXmlString } from '../formats/xml/utils/isValidXmlString';
 import { prompt } from '../pipeline/prompt-notation';
 import { promptTemplate } from '../pipeline/prompt-notation';
@@ -91,6 +92,7 @@ export { serializeError };
 export { forEachAsync };
 export { isValidCsvString };
 export { isValidJsonString };
+export { jsonParse };
 export { isValidXmlString };
 export { prompt };
 export { promptTemplate };

package/esm/typings/src/cli/common/$provideLlmToolsForCli.d.ts

@@ -1,5 +1,5 @@
-import type { LlmExecutionToolsWithTotalUsage } from '../../llm-providers/_common/utils/count-total-usage/LlmExecutionToolsWithTotalUsage';
 import type { CacheLlmToolsOptions } from '../../llm-providers/_common/utils/cache/CacheLlmToolsOptions';
+import type { LlmExecutionToolsWithTotalUsage } from '../../llm-providers/_common/utils/count-total-usage/LlmExecutionToolsWithTotalUsage';
 import type { string_promptbook_server_url } from '../../types/typeAliases';
 type ProvideLlmToolsForCliOptions = Pick<CacheLlmToolsOptions, 'isCacheReloaded'> & {
     /**

package/esm/typings/src/conversion/archive/loadArchive.d.ts

@@ -1,6 +1,6 @@
+import type { FilesystemTools } from '../../execution/FilesystemTools';
 import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
 import type { string_filename } from '../../types/typeAliases';
-import type { FilesystemTools } from '../../execution/FilesystemTools';
 /**
  * Loads the books from the archive file with `.bookc` extension
  *
@@ -10,7 +10,7 @@ import type { FilesystemTools } from '../../execution/FilesystemTools';
  *
  * @private utility of Prompbook
  */
-export declare function loadArchive(filePath: string_filename, fs: FilesystemTools): Promise<Array<PipelineJson>>;
+export declare function loadArchive(filePath: string_filename, fs: FilesystemTools): Promise<ReadonlyArray<PipelineJson>>;
 /**
  * Note: [🟢] Code in this file should never be never released in packages that could be imported into browser environment
  */

package/esm/typings/src/execution/createPipelineExecutor/getKnowledgeForTask.d.ts

@@ -3,12 +3,17 @@ import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
 import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';
 import type { string_markdown } from '../../types/typeAliases';
 import type { string_parameter_value } from '../../types/typeAliases';
+import type { ExecutionTools } from '../ExecutionTools';
 /**
  * @@@
  *
  * @private internal type of `getKnowledgeFoTask`
  */
 type GetKnowledgeForTaskOptions = {
+    /**
+     * The execution tools to be used during the execution of the pipeline
+     */
+    readonly tools: ExecutionTools;
     /**
      * @@@
      */
@@ -21,7 +26,14 @@ type GetKnowledgeForTaskOptions = {
 /**
  * @@@
  *
+ * Here is the place where RAG (retrieval-augmented generation) happens
+ *
  * @private internal utility of `createPipelineExecutor`
  */
 export declare function getKnowledgeForTask(options: GetKnowledgeForTaskOptions): Promise<string_parameter_value & string_markdown>;
 export {};
+/**
+ * TODO: !!!! Verify if this is working
+ * TODO: [♨] Implement Better - use keyword search
+ * TODO: [♨] Examples of values
+ */

package/esm/typings/src/execution/createPipelineExecutor/getReservedParametersForTask.d.ts

@@ -2,12 +2,17 @@ import type { ReadonlyDeep } from 'type-fest';
 import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
 import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';
 import type { ReservedParameters } from '../../types/typeAliases';
+import type { ExecutionTools } from '../ExecutionTools';
 /**
  * @@@
  *
  * @private internal type of `getReservedParametersForTask`
  */
 type GetReservedParametersForTaskOptions = {
+    /**
+     * The execution tools to be used during the execution of the pipeline
+     */
+    readonly tools: ExecutionTools;
     /**
      * @@@
      */

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

@@ -0,0 +1,11 @@
+/**
+ * Converts a JavaScript Object Notation (JSON) string into an object.
+ *
+ * Note: This is wrapper around `JSON.parse()` with better error and type handling
+ *
+ * @public exported from `@promptbook/utils`
+ */
+export declare function jsonParse<T>(value: string): T;
+/**
+ * TODO: !!!! Use in Promptbook.studio
+ */

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

@@ -3,6 +3,41 @@ import type { string_title } from '../../../types/typeAliases';
 import type { Registered } from '../../../utils/$Register';
 import type { string_SCREAMING_CASE } from '../../../utils/normalization/normalizeTo_SCREAMING_CASE';
 import type { LlmToolsConfiguration } from './LlmToolsConfiguration';
+/**
+ * How is the model provider trusted?
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare const MODEL_TRUST_LEVEL: {
+    readonly FULL: "Model is running on the local machine, training data and model weights are known, data are ethically sourced";
+    readonly OPEN: "Model is open source, training data and model weights are known";
+    readonly PARTIALLY_OPEN: "Model is open source, but training data and model weights are not (fully) known";
+    readonly CLOSED_LOCAL: "Model can be run locally, but it is not open source";
+    readonly CLOSED_FREE: "Model is behind API gateway but free to use";
+    readonly CLOSED_BUSINESS: "Model is behind API gateway and paid but has good SLA, TOS, privacy policy and in general is a good to use in business applications";
+    readonly CLOSED: "Model is behind API gateway and paid";
+    readonly UNTRUSTED: "Model has questions about the training data and ethics, but it is not known if it is a problem or not";
+    readonly VURNABLE: "Model has some known serious vulnerabilities, leaks, ethical problems, etc.";
+};
+/**
+ * How is the model provider important?
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare const MODEL_ORDER: {
+    /**
+     * Top-tier models, e.g. OpenAI, Anthropic,...
+     */
+    readonly TOP_TIER: 333;
+    /**
+     * Mid-tier models, e.g. Llama, Mistral, etc.
+     */
+    readonly NORMAL: 100;
+    /**
+     * Low-tier models, e.g. Phi, Tiny, etc.
+     */
+    readonly LOW_TIER: 0;
+};
 /**
  * @@@
  *
@@ -13,6 +48,14 @@ export type LlmToolsMetadata = Registered & {
      * @@@
      */
     readonly title: string_title;
+    /**
+     * How is the model is trusted?
+     */
+    readonly trustLevel: keyof typeof MODEL_TRUST_LEVEL;
+    /**
+     * How is the model provider important and should be sorted in the list of available providers?
+     */
+    readonly order: typeof MODEL_ORDER[keyof typeof MODEL_ORDER] | number;
     /**
      * List of environment variables that can be used to configure the provider
      *

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

@@ -28,7 +28,9 @@ export type paths = {
                     headers: {
                         readonly [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        readonly "text/markdown": string;
+                    };
                 };
             };
         };
@@ -71,16 +73,44 @@ export type paths = {
             };
             readonly responses: {
                 /** @description Successful login */
-                readonly 200: {
+                readonly 201: {
                     headers: {
                         readonly [name: string]: unknown;
                     };
                     content: {
                         readonly "application/json": {
+                            readonly isSuccess?: boolean;
+                            readonly message?: string;
+                            readonly error?: Record<string, never>;
                             readonly identification?: Record<string, never>;
                         };
                     };
                 };
+                /** @description Bad request or login failed */
+                readonly 400: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": {
+                            readonly error?: Record<string, never>;
+                        };
+                    };
+                };
+                /** @description Authentication error */
+                readonly 401: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": {
+                            /** @enum {boolean} */
+                            readonly isSuccess?: false;
+                            readonly message?: string;
+                            readonly error?: Record<string, never>;
+                        };
+                    };
+                };
             };
         };
         readonly delete?: never;
@@ -118,6 +148,15 @@ export type paths = {
                         readonly "application/json": readonly string[];
                     };
                 };
+                /** @description No collection available */
+                readonly 500: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "text/plain": string;
+                    };
+                };
             };
         };
         readonly put?: never;
@@ -128,7 +167,7 @@ export type paths = {
         readonly patch?: never;
         readonly trace?: never;
     };
-    readonly [path: `/books/${string}`]: {
+    readonly "/books/{bookId}": {
         readonly parameters: {
             readonly query?: never;
             readonly header?: never;
@@ -165,7 +204,20 @@ export type paths = {
                     headers: {
                         readonly [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        readonly "application/json": {
+                            readonly error?: Record<string, never>;
+                        };
+                    };
+                };
+                /** @description No collection available */
+                readonly 500: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "text/plain": string;
+                    };
                 };
             };
         };
@@ -203,7 +255,139 @@ export type paths = {
                         readonly [name: string]: unknown;
                     };
                     content: {
-                        readonly "application/json": readonly Record<string, never>[];
+                        readonly "application/json": readonly {
+                            readonly nonce?: string;
+                            readonly taskId?: string;
+                            readonly taskType?: string;
+                            readonly status?: string;
+                            /** Format: date-time */
+                            readonly createdAt?: string;
+                            /** Format: date-time */
+                            readonly updatedAt?: string;
+                        }[];
+                    };
+                };
+            };
+        };
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/executions/last": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * Get the last execution
+         * @description Returns details of the last execution task.
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description The last execution task with full details. */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": {
+                            readonly nonce?: string;
+                            readonly taskId?: string;
+                            readonly taskType?: string;
+                            readonly status?: string;
+                            readonly errors?: readonly Record<string, never>[];
+                            readonly warnings?: readonly Record<string, never>[];
+                            /** Format: date-time */
+                            readonly createdAt?: string;
+                            /** Format: date-time */
+                            readonly updatedAt?: string;
+                            readonly currentValue?: Record<string, never>;
+                        };
+                    };
+                };
+                /** @description No execution tasks found. */
+                readonly 404: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "text/plain": string;
+                    };
+                };
+            };
+        };
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/executions/{taskId}": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * Get specific execution
+         * @description Returns details of a specific execution task.
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path: {
+                    /** @description The ID of the execution task to retrieve. */
+                    readonly taskId: string;
+                };
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description The execution task with full details. */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": {
+                            readonly nonce?: string;
+                            readonly taskId?: string;
+                            readonly taskType?: string;
+                            readonly status?: string;
+                            readonly errors?: readonly Record<string, never>[];
+                            readonly warnings?: readonly Record<string, never>[];
+                            /** Format: date-time */
+                            readonly createdAt?: string;
+                            /** Format: date-time */
+                            readonly updatedAt?: string;
+                            readonly currentValue?: Record<string, never>;
+                        };
+                    };
+                };
+                /** @description Execution task not found. */
+                readonly 404: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "text/plain": string;
                     };
                 };
             };
@@ -239,8 +423,13 @@ export type paths = {
             readonly requestBody: {
                 readonly content: {
                     readonly "application/json": {
+                        /** @description URL of the pipeline to execute */
                         readonly pipelineUrl?: string;
+                        /** @description Alternative field for pipelineUrl */
+                        readonly book?: string;
+                        /** @description Parameters for pipeline execution */
                         readonly inputParameters?: Record<string, never>;
+                        /** @description User identification data */
                         readonly identification?: Record<string, never>;
                     };
                 };
@@ -257,6 +446,91 @@ export type paths = {
                 };
                 /** @description Invalid input. */
                 readonly 400: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": {
+                            readonly error?: Record<string, never>;
+                        };
+                    };
+                };
+                /** @description Pipeline not found. */
+                readonly 404: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "text/plain": string;
+                    };
+                };
+            };
+        };
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/api-docs": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * API documentation UI
+         * @description Swagger UI for API documentation
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description HTML Swagger UI */
+                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 "/swagger": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * API documentation UI (alternative path)
+         * @description Swagger UI for API documentation
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description HTML Swagger UI */
+                readonly 200: {
                     headers: {
                         readonly [name: string]: unknown;
                     };
@@ -264,6 +538,47 @@ export type paths = {
                 };
             };
         };
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/openapi": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * OpenAPI specification
+         * @description Returns the OpenAPI JSON specification
+         */
+        readonly get: {
+            readonly parameters: {
+                readonly query?: never;
+                readonly header?: never;
+                readonly path?: never;
+                readonly cookie?: never;
+            };
+            readonly requestBody?: never;
+            readonly responses: {
+                /** @description OpenAPI specification */
+                readonly 200: {
+                    headers: {
+                        readonly [name: string]: unknown;
+                    };
+                    content: {
+                        readonly "application/json": Record<string, never>;
+                    };
+                };
+            };
+        };
+        readonly put?: never;
+        readonly post?: never;
         readonly delete?: never;
         readonly options?: never;
         readonly head?: never;
@@ -273,7 +588,34 @@ export type paths = {
 };
 export type webhooks = Record<string, never>;
 export type components = {
-    schemas: never;
+    schemas: {
+        readonly Error: {
+            readonly error?: Record<string, never>;
+        };
+        readonly ExecutionTaskSummary: {
+            readonly nonce?: string;
+            readonly taskId?: string;
+            readonly taskType?: string;
+            readonly status?: string;
+            /** Format: date-time */
+            readonly createdAt?: string;
+            /** Format: date-time */
+            readonly updatedAt?: string;
+        };
+        readonly ExecutionTaskFull: {
+            readonly nonce?: string;
+            readonly taskId?: string;
+            readonly taskType?: string;
+            readonly status?: string;
+            readonly errors?: readonly Record<string, never>[];
+            readonly warnings?: readonly Record<string, never>[];
+            /** Format: date-time */
+            readonly createdAt?: string;
+            /** Format: date-time */
+            readonly updatedAt?: string;
+            readonly currentValue?: Record<string, never>;
+        };
+    };
     responses: never;
     parameters: never;
     requestBodies: never;