@digipair/skill-llm 0.114.1 → 0.114.3

package/dist/index.cjs.js

@@ -1,12 +1,229 @@
 'use strict';
 
-var index = require('./index.cjs2.js');
-require('@digipair/engine');
+var engine = require('@digipair/engine');
+var messages = require('@langchain/core/messages');
+var prompts = require('@langchain/core/prompts');
+var runnables = require('@langchain/core/runnables');
+var chains = require('langchain/chains');
+var output_parsers = require('langchain/output_parsers');
+var text_splitter = require('langchain/text_splitter');
+var zod = require('zod');
 
+let LLMService = class LLMService {
+    objectToInput(obj) {
+        const result = {};
+        for(const key in obj){
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                result[key] = ()=>obj[key];
+            }
+        }
+        return result;
+    }
+    jsonSchemaToZod(schema) {
+        const zodProps = {};
+        switch(schema.type){
+            case 'string':
+                return zod.z.string().optional();
+            case 'number':
+                return zod.z.number().optional();
+            case 'boolean':
+                return zod.z.boolean().optional();
+            case 'object':
+                for(const prop in schema.properties){
+                    zodProps[prop] = this.jsonSchemaToZod(schema.properties[prop]);
+                    if (schema.properties[prop].description) {
+                        zodProps[prop] = zodProps[prop].describe(schema.properties[prop].description);
+                    }
+                }
+                return zod.z.object(zodProps).required((schema.required ?? []).reduce((acc, reqProp)=>({
+                        ...acc,
+                        [reqProp]: true
+                    }), {})).optional();
+            case 'array':
+                if (schema.items) {
+                    return zod.z.array(this.jsonSchemaToZod(schema.items)).optional();
+                }
+                return zod.z.array(zod.z.unknown()).optional();
+            default:
+                throw new Error(`Unsupported JSON Schema type: ${schema.type}`);
+        }
+    }
+    async invoke(params, _pinsSettingsList, context) {
+        const { execute, input = {} } = params;
+        const chain = runnables.RunnableSequence.from([
+            this.objectToInput(input),
+            ...await Promise.all(execute.map((pinsSettings, i)=>engine.executePinsList([
+                    pinsSettings
+                ], context, `${context.__PATH__}.execute[${i}]`)))
+        ]);
+        let model;
+        let service;
+        const result = await chain.invoke({}, {
+            callbacks: [
+                {
+                    handleChatModelStart: async ({ id }, _1, _2, _3, extrasParams)=>{
+                        model = (extrasParams?.['invocation_params']).model;
+                        service = id[2];
+                    },
+                    handleLLMStart: async ({ id }, _1, _2, _3, extrasParams)=>{
+                        model = (extrasParams?.['invocation_params']).model;
+                        service = id[2];
+                    },
+                    handleLLMEnd: async (infos)=>{
+                        const { completionTokens, promptTokens } = infos.llmOutput?.['tokenUsage'] || {
+                            completionTokens: 0,
+                            promptTokens: 0
+                        };
+                        const skillLogger = require('@digipair/skill-logger');
+                        await skillLogger.addConsumption(context, service, model, promptTokens, completionTokens);
+                    }
+                }
+            ]
+        });
+        return result;
+    }
+    async reasoningStep(params, _pinsSettingsList, context) {
+        const { attributes } = params;
+        const data = {};
+        let i = 0;
+        for (const attribute of attributes){
+            data[attribute.name] = async (previous)=>await engine.executePinsList(attribute.value, {
+                    ...context,
+                    previous,
+                    parent: {
+                        previous: context.previous,
+                        parent: context.parent
+                    }
+                }, `${context.__PATH__}.attributes[${i}]`);
+            i++;
+        }
+        return data;
+    }
+    async basic(params, _pins, context) {
+        const { model, prompt, schema } = params;
+        let chain;
+        if (!schema) {
+            const modelInstance = await engine.executePinsList(model ?? context.privates.MODEL_LLM, context, `${context.__PATH__}.model`);
+            chain = runnables.RunnableSequence.from([
+                prompts.PromptTemplate.fromTemplate(prompt ?? '{prompt}'),
+                modelInstance
+            ]);
+        } else {
+            const modelInstance = await engine.executePinsList(model ?? context.privates.MODEL_LLM_JSON ?? context.privates.MODEL_LLM, context, `${context.__PATH__}.model`);
+            const parser = new output_parsers.StructuredOutputParser(this.jsonSchemaToZod(schema));
+            chain = runnables.RunnableSequence.from([
+                prompts.PromptTemplate.fromTemplate(`${prompt ?? '{prompt}'}
+          
+          Answer the users question as best as possible.
+          {format_instructions}
+          
+          JSON:`, {
+                    partialVariables: {
+                        format_instructions: parser.getFormatInstructions()
+                    }
+                }),
+                modelInstance,
+                parser
+            ]);
+        }
+        return chain;
+    }
+    async vision(params, _pins, context) {
+        const { model, prompt, schema, image } = params;
+        let chain;
+        if (!schema) {
+            const modelInstance = await engine.executePinsList(model ?? context.privates.MODEL_VISION ?? context.privates.MODEL_LLM, context, `${context.__PATH__}.model`);
+            chain = runnables.RunnableSequence.from([
+                prompts.PromptTemplate.fromTemplate(prompt ?? '{prompt}'),
+                (text)=>[
+                        new messages.HumanMessage({
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: text.value
+                                },
+                                {
+                                    type: 'image_url',
+                                    image_url: {
+                                        url: image
+                                    }
+                                }
+                            ]
+                        })
+                    ],
+                modelInstance
+            ]);
+        } else {
+            const modelInstance = await engine.executePinsList(model ?? context.privates.MODEL_VISION_JSON ?? context.privates.MODEL_VISION ?? context.privates.MODEL_LLM_JSON ?? context.privates.MODEL_LLM, context, `${context.__PATH__}.model`);
+            const parser = new output_parsers.StructuredOutputParser(this.jsonSchemaToZod(schema));
+            chain = runnables.RunnableSequence.from([
+                prompts.PromptTemplate.fromTemplate(`${prompt ?? '{prompt}'}
+            
+            Answer the users question as best as possible.
+            {format_instructions}
+            
+            JSON:`, {
+                    partialVariables: {
+                        format_instructions: parser.getFormatInstructions()
+                    }
+                }),
+                (text)=>[
+                        new messages.HumanMessage({
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: text.value
+                                },
+                                {
+                                    type: 'image_url',
+                                    image_url: {
+                                        url: image
+                                    }
+                                }
+                            ]
+                        })
+                    ],
+                modelInstance,
+                parser
+            ]);
+        }
+        return chain;
+    }
+    async summarization(params, _pins, context) {
+        const { model = context.privates.MODEL_LLM, chunkSize = 1024, type = 'map_reduce', verbose = false, prompt, combineMapPrompt, combinePrompt, returnIntermediateSteps, refinePrompt, questionPrompt } = params;
+        const modelInstance = await engine.executePinsList(model, context, `${context.__PATH__}.model`);
+        const textSplitter = new text_splitter.RecursiveCharacterTextSplitter({
+            chunkSize
+        });
+        const summarizationChain = chains.loadSummarizationChain(modelInstance, {
+            type,
+            verbose,
+            prompt: !prompt ? undefined : prompts.PromptTemplate.fromTemplate(prompt),
+            combineMapPrompt: !combineMapPrompt ? undefined : prompts.PromptTemplate.fromTemplate(combineMapPrompt),
+            combinePrompt: !combinePrompt ? undefined : prompts.PromptTemplate.fromTemplate(combinePrompt),
+            returnIntermediateSteps,
+            refinePrompt: !refinePrompt ? undefined : prompts.PromptTemplate.fromTemplate(refinePrompt),
+            questionPrompt: !questionPrompt ? undefined : prompts.PromptTemplate.fromTemplate(questionPrompt)
+        });
+        const chain = runnables.RunnableSequence.from([
+            {
+                input_documents: async ({ document })=>await textSplitter.createDocuments([
+                        document
+                    ])
+            },
+            summarizationChain
+        ]);
+        return chain;
+    }
+};
+const invoke = (params, pinsSettingsList, context)=>new LLMService().invoke(params, pinsSettingsList, context);
+const reasoningStep = (params, pinsSettingsList, context)=>new LLMService().reasoningStep(params, pinsSettingsList, context);
+const basic = (params, pinsSettingsList, context)=>new LLMService().basic(params, pinsSettingsList, context);
+const vision = (params, pinsSettingsList, context)=>new LLMService().vision(params, pinsSettingsList, context);
+const summarization = (params, pinsSettingsList, context)=>new LLMService().summarization(params, pinsSettingsList, context);
 
-
-exports.basic = index.basic;
-exports.invoke = index.invoke;
-exports.reasoningStep = index.reasoningStep;
-exports.summarization = index.summarization;
-exports.vision = index.vision;
+exports.basic = basic;
+exports.invoke = invoke;
+exports.reasoningStep = reasoningStep;
+exports.summarization = summarization;
+exports.vision = vision;

package/dist/index.esm2.js

@@ -22838,14 +22838,14 @@ function indent(str, spaces) {
         var match = parseIdentifier(input, i1, namePart) || namePart && parseAdditionalSymbol(input, i1) || maybeSpace && parseSpaces(input, i1);
         // match is required
         if (!match) {
-            return tokens = tokens1, nextMatch = nextMatch1, i = i1, {
+            return nextMatch = nextMatch1, tokens = tokens1, i = i1, {
                 v: nextMatch1
             };
         }
         var token = match.token, offset = match.offset;
         i1 += offset;
         if (token === ' ') {
-            return tokens = tokens1, nextMatch = nextMatch1, i = i1, "continue";
+            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
         }
         tokens1 = _to_consumable_array$4$1(tokens1).concat([
             token
@@ -22864,7 +22864,7 @@ function indent(str, spaces) {
         if (contextKeys.some(function(el) {
             return el.startsWith(name);
         })) {
-            return tokens = tokens1, nextMatch = nextMatch1, i = i1, "continue";
+            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
         }
         if (dateTimeIdentifiers.some(function(el) {
             return el === name;
@@ -22883,9 +22883,9 @@ function indent(str, spaces) {
         if (dateTimeIdentifiers.some(function(el) {
             return el.startsWith(name);
         })) {
-            return tokens = tokens1, nextMatch = nextMatch1, i = i1, "continue";
+            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
         }
-        return tokens = tokens1, nextMatch = nextMatch1, i = i1, {
+        return nextMatch = nextMatch1, tokens = tokens1, i = i1, {
             v: nextMatch1
         };
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digipair/skill-llm",
-  "version": "0.114.1",
+  "version": "0.114.3",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",
   "types": "./dist/index.d.ts",
@@ -31,5 +31,9 @@
   "nx": {
     "name": "skill-llm"
   },
-  "dependencies": {}
+  "dependencies": {
+    "langchain": "^0.3.5",
+    "@langchain/core": "^0.3.15",
+    "zod": "^3.23.8"
+  }
 }