@promptbook/remote-server 0.92.0-5 → 0.92.0-7

package/esm/index.es.js

@@ -33,7 +33,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.92.0-5';
+const PROMPTBOOK_ENGINE_VERSION = '0.92.0-7';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1833,6 +1833,45 @@ function isValidJsonString(value /* <- [👨‍⚖️] */) {
     }
 }
 
+/**
+ * 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`
+ */
+function jsonParse(value) {
+    if (value === undefined) {
+        throw new Error(`Can not parse JSON from undefined value.`);
+    }
+    else if (typeof value !== 'string') {
+        console.error('Can not parse JSON from non-string value.', { text: value });
+        throw new Error(spaceTrim(`
+                    Can not parse JSON from non-string value.
+
+                    The value type: ${typeof value}
+                    See more in console.
+                `));
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        throw new Error(spaceTrim((block) => `
+                    ${block(error.message)}
+            
+                    The JSON text:
+                    ${block(value)}
+                `));
+    }
+}
+/**
+ * TODO: !!!! Use in Promptbook.studio
+ */
+
 /**
  * Recursively converts JSON strings to JSON objects
 
@@ -1851,7 +1890,7 @@ function jsonStringsToJsons(object) {
     const newObject = { ...object };
     for (const [key, value] of Object.entries(object)) {
         if (typeof value === 'string' && isValidJsonString(value)) {
-            newObject[key] = JSON.parse(value);
+            newObject[key] = jsonParse(value);
         }
         else {
             newObject[key] = jsonStringsToJsons(value);
@@ -2934,18 +2973,26 @@ async function preparePersona(personaDescription, tools, options) {
     }).asPromise();
     const { outputParameters } = result;
     const { modelsRequirements: modelsRequirementsJson } = outputParameters;
-    const modelsRequirementsUnchecked = JSON.parse(modelsRequirementsJson);
+    let modelsRequirementsUnchecked = jsonParse(modelsRequirementsJson);
     if (isVerbose) {
         console.info(`PERSONA ${personaDescription}`, modelsRequirementsUnchecked);
     }
     if (!Array.isArray(modelsRequirementsUnchecked)) {
-        throw new UnexpectedError(spaceTrim((block) => `
+        // <- TODO: Book should have syntax and system to enforce shape of JSON
+        modelsRequirementsUnchecked = [modelsRequirementsUnchecked];
+        /*
+        throw new UnexpectedError(
+            spaceTrim(
+                (block) => `
                     Invalid \`modelsRequirements\`:
 
                     \`\`\`json
                     ${block(JSON.stringify(modelsRequirementsUnchecked, null, 4))}
                     \`\`\`
-                `));
+                `,
+            ),
+        );
+        */
     }
     const modelsRequirements = modelsRequirementsUnchecked.map((modelRequirements) => ({
         modelVariant: 'CHAT',
@@ -3776,7 +3823,7 @@ async function makeKnowledgeSourceHandler(knowledgeSource, tools, options) {
                 > },
             */
             async asJson() {
-                return JSON.parse(await tools.fs.readFile(filename, 'utf-8'));
+                return jsonParse(await tools.fs.readFile(filename, 'utf-8'));
             },
             async asText() {
                 return await tools.fs.readFile(filename, 'utf-8');
@@ -5480,13 +5527,79 @@ async function getExamplesForTask(task) {
 /**
  * @@@
  *
+ * Here is the place where RAG (retrieval-augmented generation) happens
+ *
  * @private internal utility of `createPipelineExecutor`
  */
 async function getKnowledgeForTask(options) {
-    const { preparedPipeline, task } = options;
-    return preparedPipeline.knowledgePieces.map(({ content }) => `- ${content}`).join('\n');
+    const { tools, preparedPipeline, task } = options;
+    const firstKnowlegePiece = preparedPipeline.knowledgePieces[0];
+    const firstKnowlegeIndex = firstKnowlegePiece === null || firstKnowlegePiece === void 0 ? void 0 : firstKnowlegePiece.index[0];
+    // <- TODO: Do not use just first knowledge piece and first index to determine embedding model, use also keyword search
+    if (firstKnowlegePiece === undefined || firstKnowlegeIndex === undefined) {
+        return 'No knowledge pieces found';
+    }
+    // TODO: [🚐] Make arrayable LLMs -> single LLM DRY
+    const _llms = arrayableToArray(tools.llm);
+    const llmTools = _llms.length === 1 ? _llms[0] : joinLlmExecutionTools(..._llms);
+    const taskEmbeddingPrompt = {
+        title: 'Knowledge Search',
+        modelRequirements: {
+            modelVariant: 'EMBEDDING',
+            modelName: firstKnowlegeIndex.modelName,
+        },
+        content: task.content,
+        parameters: {
+        /* !!!!!!!! */
+        },
+    };
+    const taskEmbeddingResult = await llmTools.callEmbeddingModel(taskEmbeddingPrompt);
+    const knowledgePiecesWithRelevance = preparedPipeline.knowledgePieces.map((knowledgePiece) => {
+        const { index } = knowledgePiece;
+        const knowledgePieceIndex = index.find((i) => i.modelName === firstKnowlegeIndex.modelName);
+        // <- TODO: Do not use just first knowledge piece and first index to determine embedding model
+        if (knowledgePieceIndex === undefined) {
+            return {
+                content: knowledgePiece.content,
+                relevance: 0,
+            };
+        }
+        const relevance = computeCosineSimilarity(knowledgePieceIndex.position, taskEmbeddingResult.content);
+        return {
+            content: knowledgePiece.content,
+            relevance,
+        };
+    });
+    const knowledgePiecesSorted = knowledgePiecesWithRelevance.sort((a, b) => a.relevance - b.relevance);
+    const knowledgePiecesLimited = knowledgePiecesSorted.slice(0, 5);
+    console.log('!!! Embedding', {
+        task,
+        taskEmbeddingPrompt,
+        taskEmbeddingResult,
+        firstKnowlegePiece,
+        firstKnowlegeIndex,
+        knowledgePiecesWithRelevance,
+        knowledgePiecesSorted,
+        knowledgePiecesLimited,
+    });
+    return knowledgePiecesLimited.map(({ content }) => `- ${content}`).join('\n');
     //                                                      <- TODO: [🧠] Some smart aggregation of knowledge pieces, single-line vs multi-line vs mixed
 }
+// TODO: !!!!!! Annotate + to new file
+function computeCosineSimilarity(embeddingVector1, embeddingVector2) {
+    if (embeddingVector1.length !== embeddingVector2.length) {
+        throw new TypeError('Embedding vectors must have the same length');
+    }
+    const dotProduct = embeddingVector1.reduce((sum, value, index) => sum + value * embeddingVector2[index], 0);
+    const magnitude1 = Math.sqrt(embeddingVector1.reduce((sum, value) => sum + value * value, 0));
+    const magnitude2 = Math.sqrt(embeddingVector2.reduce((sum, value) => sum + value * value, 0));
+    return 1 - dotProduct / (magnitude1 * magnitude2);
+}
+/**
+ * TODO: !!!! Verify if this is working
+ * TODO: [♨] Implement Better - use keyword search
+ * TODO: [♨] Examples of values
+ */
 
 /**
  * @@@
@@ -5494,9 +5607,9 @@ async function getKnowledgeForTask(options) {
  * @private internal utility of `createPipelineExecutor`
  */
 async function getReservedParametersForTask(options) {
-    const { preparedPipeline, task, pipelineIdentification } = options;
+    const { tools, preparedPipeline, task, pipelineIdentification } = options;
     const context = await getContextForTask(); // <- [🏍]
-    const knowledge = await getKnowledgeForTask({ preparedPipeline, task });
+    const knowledge = await getKnowledgeForTask({ tools, preparedPipeline, task });
     const examples = await getExamplesForTask();
     const currentDate = new Date().toISOString(); // <- TODO: [🧠][💩] Better
     const modelName = RESERVED_PARAMETER_MISSING_VALUE;
@@ -5558,6 +5671,7 @@ async function executeTask(options) {
     }
     const definedParameters = Object.freeze({
         ...(await getReservedParametersForTask({
+            tools,
             preparedPipeline,
             task: currentTask,
             pipelineIdentification,
@@ -6848,7 +6962,7 @@ async function $provideScriptingForNode(options) {
 const openapiJson = {
     openapi: '3.0.0',
     info: {
-        title: 'Promptbook Remote Server API (!!!! From TS)',
+        title: 'Promptbook Remote Server API (!!!! From YML)',
         version: '1.0.0',
         description: 'API documentation for the Promptbook Remote Server',
     },
@@ -6860,6 +6974,13 @@ const openapiJson = {
                 responses: {
                     '200': {
                         description: 'Server details in markdown format.',
+                        content: {
+                            'text/markdown': {
+                                schema: {
+                                    type: 'string',
+                                },
+                            },
+                        },
                     },
                 },
             },
@@ -6890,13 +7011,22 @@ const openapiJson = {
                     },
                 },
                 responses: {
-                    '200': {
+                    '201': {
                         description: 'Successful login',
                         content: {
                             'application/json': {
                                 schema: {
                                     type: 'object',
                                     properties: {
+                                        isSuccess: {
+                                            type: 'boolean',
+                                        },
+                                        message: {
+                                            type: 'string',
+                                        },
+                                        error: {
+                                            type: 'object',
+                                        },
                                         identification: {
                                             type: 'object',
                                         },
@@ -6905,6 +7035,43 @@ const openapiJson = {
                             },
                         },
                     },
+                    '400': {
+                        description: 'Bad request or login failed',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        error: {
+                                            type: 'object',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    '401': {
+                        description: 'Authentication error',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        isSuccess: {
+                                            type: 'boolean',
+                                            enum: [false],
+                                        },
+                                        message: {
+                                            type: 'string',
+                                        },
+                                        error: {
+                                            type: 'object',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
                 },
             },
         },
@@ -6926,6 +7093,16 @@ const openapiJson = {
                             },
                         },
                     },
+                    '500': {
+                        description: 'No collection available',
+                        content: {
+                            'text/plain': {
+                                schema: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                    },
                 },
             },
         },
@@ -6957,6 +7134,28 @@ const openapiJson = {
                     },
                     '404': {
                         description: 'Book not found.',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        error: {
+                                            type: 'object',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    '500': {
+                        description: 'No collection available',
+                        content: {
+                            'text/plain': {
+                                schema: {
+                                    type: 'string',
+                                },
+                            },
+                        },
                     },
                 },
             },
@@ -6974,6 +7173,28 @@ const openapiJson = {
                                     type: 'array',
                                     items: {
                                         type: 'object',
+                                        properties: {
+                                            nonce: {
+                                                type: 'string',
+                                            },
+                                            taskId: {
+                                                type: 'string',
+                                            },
+                                            taskType: {
+                                                type: 'string',
+                                            },
+                                            status: {
+                                                type: 'string',
+                                            },
+                                            createdAt: {
+                                                type: 'string',
+                                                format: 'date-time',
+                                            },
+                                            updatedAt: {
+                                                type: 'string',
+                                                format: 'date-time',
+                                            },
+                                        },
                                     },
                                 },
                             },
@@ -6982,6 +7203,147 @@ const openapiJson = {
                 },
             },
         },
+        '/executions/last': {
+            get: {
+                summary: 'Get the last execution',
+                description: 'Returns details of the last execution task.',
+                responses: {
+                    '200': {
+                        description: 'The last execution task with full details.',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        nonce: {
+                                            type: 'string',
+                                        },
+                                        taskId: {
+                                            type: 'string',
+                                        },
+                                        taskType: {
+                                            type: 'string',
+                                        },
+                                        status: {
+                                            type: 'string',
+                                        },
+                                        errors: {
+                                            type: 'array',
+                                            items: {
+                                                type: 'object',
+                                            },
+                                        },
+                                        warnings: {
+                                            type: 'array',
+                                            items: {
+                                                type: 'object',
+                                            },
+                                        },
+                                        createdAt: {
+                                            type: 'string',
+                                            format: 'date-time',
+                                        },
+                                        updatedAt: {
+                                            type: 'string',
+                                            format: 'date-time',
+                                        },
+                                        currentValue: {
+                                            type: 'object',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    '404': {
+                        description: 'No execution tasks found.',
+                        content: {
+                            'text/plain': {
+                                schema: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/executions/{taskId}': {
+            get: {
+                summary: 'Get specific execution',
+                description: 'Returns details of a specific execution task.',
+                parameters: [
+                    {
+                        in: 'path',
+                        name: 'taskId',
+                        required: true,
+                        schema: {
+                            type: 'string',
+                        },
+                        description: 'The ID of the execution task to retrieve.',
+                    },
+                ],
+                responses: {
+                    '200': {
+                        description: 'The execution task with full details.',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        nonce: {
+                                            type: 'string',
+                                        },
+                                        taskId: {
+                                            type: 'string',
+                                        },
+                                        taskType: {
+                                            type: 'string',
+                                        },
+                                        status: {
+                                            type: 'string',
+                                        },
+                                        errors: {
+                                            type: 'array',
+                                            items: {
+                                                type: 'object',
+                                            },
+                                        },
+                                        warnings: {
+                                            type: 'array',
+                                            items: {
+                                                type: 'object',
+                                            },
+                                        },
+                                        createdAt: {
+                                            type: 'string',
+                                            format: 'date-time',
+                                        },
+                                        updatedAt: {
+                                            type: 'string',
+                                            format: 'date-time',
+                                        },
+                                        currentValue: {
+                                            type: 'object',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    '404': {
+                        description: 'Execution task not found.',
+                        content: {
+                            'text/plain': {
+                                schema: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
         '/executions/new': {
             post: {
                 summary: 'Start a new execution',
@@ -6995,12 +7357,19 @@ const openapiJson = {
                                 properties: {
                                     pipelineUrl: {
                                         type: 'string',
+                                        description: 'URL of the pipeline to execute',
+                                    },
+                                    book: {
+                                        type: 'string',
+                                        description: 'Alternative field for pipelineUrl',
                                     },
                                     inputParameters: {
                                         type: 'object',
+                                        description: 'Parameters for pipeline execution',
                                     },
                                     identification: {
                                         type: 'object',
+                                        description: 'User identification data',
                                     },
                                 },
                             },
@@ -7020,13 +7389,164 @@ const openapiJson = {
                     },
                     '400': {
                         description: 'Invalid input.',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        error: {
+                                            type: 'object',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    '404': {
+                        description: 'Pipeline not found.',
+                        content: {
+                            'text/plain': {
+                                schema: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/api-docs': {
+            get: {
+                summary: 'API documentation UI',
+                description: 'Swagger UI for API documentation',
+                responses: {
+                    '200': {
+                        description: 'HTML Swagger UI',
+                    },
+                },
+            },
+        },
+        '/swagger': {
+            get: {
+                summary: 'API documentation UI (alternative path)',
+                description: 'Swagger UI for API documentation',
+                responses: {
+                    '200': {
+                        description: 'HTML Swagger UI',
+                    },
+                },
+            },
+        },
+        '/openapi': {
+            get: {
+                summary: 'OpenAPI specification',
+                description: 'Returns the OpenAPI JSON specification',
+                responses: {
+                    '200': {
+                        description: 'OpenAPI specification',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    components: {
+        schemas: {
+            Error: {
+                type: 'object',
+                properties: {
+                    error: {
+                        type: 'object',
+                    },
+                },
+            },
+            ExecutionTaskSummary: {
+                type: 'object',
+                properties: {
+                    nonce: {
+                        type: 'string',
+                    },
+                    taskId: {
+                        type: 'string',
+                    },
+                    taskType: {
+                        type: 'string',
+                    },
+                    status: {
+                        type: 'string',
+                    },
+                    createdAt: {
+                        type: 'string',
+                        format: 'date-time',
+                    },
+                    updatedAt: {
+                        type: 'string',
+                        format: 'date-time',
+                    },
+                },
+            },
+            ExecutionTaskFull: {
+                type: 'object',
+                properties: {
+                    nonce: {
+                        type: 'string',
+                    },
+                    taskId: {
+                        type: 'string',
+                    },
+                    taskType: {
+                        type: 'string',
+                    },
+                    status: {
+                        type: 'string',
+                    },
+                    errors: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                        },
+                    },
+                    warnings: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                        },
+                    },
+                    createdAt: {
+                        type: 'string',
+                        format: 'date-time',
+                    },
+                    updatedAt: {
+                        type: 'string',
+                        format: 'date-time',
+                    },
+                    currentValue: {
+                        type: 'object',
                     },
                 },
             },
         },
     },
-    components: {},
-    tags: [],
+    tags: [
+        {
+            name: 'Books',
+            description: 'Operations related to books and pipelines',
+        },
+        {
+            name: 'Executions',
+            description: 'Operations related to execution tasks',
+        },
+        {
+            name: 'Authentication',
+            description: 'Authentication operations',
+        },
+    ],
 };
 /**
  * Note: [💞] Ignore a discrepancy between file name and entity name