@semantictools/ai-toolbox 0.1.0

package/src/translators/atfunc.mjs

@@ -0,0 +1,450 @@
+
+
+let separator = " ----------------- \n";
+let afterPadding = "\n";
+
+
+function typifyValue( value, type ) {
+    if( type === "number" ) {
+        let n = Number( value );
+        if( !isNaN( n )) {
+            return n;
+        }
+    }
+    else if( type === "boolean" ) {
+        let vLower = value.toLowerCase();
+        if( vLower === "true" || vLower === "false" ) {
+            return ( vLower === "true" );
+        }
+    }
+    else if( type === "string" ) {
+       // surrounded but quotes, remove them
+        if( ( value.startsWith('"') && value.endsWith('"') ) ||
+            ( value.startsWith("'") && value.endsWith("'") ) ) {
+            return value.substring( 1, value.length - 1 );
+        }   
+    }    
+    //default to string
+    return value;
+}
+
+
+
+function getFunctionCallsFromText( text, interfaces, rootToolBox ) {
+
+    let lines = text.split("\n");
+    let fCalls = [];
+
+    fCalls = [];
+    for( let i=0; i<lines.length; i++ ) {
+        let line = lines[i].trim();
+        if( line.startsWith("@") ) {
+            let funcCall = ""; //line.substring(1, endIdx );
+            let paramStart = line.indexOf("(")+1;
+            let paramStartFound = paramStart != 0;
+
+            let parseState = {
+                inQuote: false,
+                escape: false,
+                buffer: ""
+            };
+
+            let params = [];
+            for( let j=paramStart; j<line.length; j++ ) {
+                let char = line[j];
+
+                if( (char == "," || char == ")") && !parseState.escape && !parseState.inQuote ) {
+                    params.push( parseState.buffer.trim() );
+                    parseState.buffer = "";
+                    if( char == ")" ) {
+                        break;
+                    }
+                }
+                else if( char == "\"" && !parseState.escape ) {
+                    parseState.inQuote = !parseState.inQuote;
+                    parseState.buffer += char;
+                }
+                else if( char == "\\" && !parseState.escape ) {
+                    parseState.escape = true;
+                }
+                else if( parseState.escape ) {
+                    parseState.escape = false;
+                    if( char == "n") {
+                        parseState.buffer += "\n";
+                    }
+                    else if( char == "t") {
+                        parseState.buffer += "\t";
+                    }
+                    else if( char == "\"") {
+                        parseState.buffer += "\"";
+                    }
+                    else if( char == ",") {
+                        parseState.buffer += ",";
+                    }                    
+                    else {
+                        parseState.buffer += "?";
+                    }
+                }
+                else {
+                    parseState.buffer += char;
+                }
+
+            }
+            //adjust funcCall to not include rest if brackets and/or params exist
+            if( paramStartFound ) {
+                funcCall = line.substring(1, paramStart-1 ).trim();
+            }
+
+            if( funcCall.indexOf(".") == -1 && rootToolBox ) {
+                funcCall = rootToolBox + "." + funcCall;
+            }
+
+            //check with after the last ) there is a "with_body [[" and if so, take the rest of the line as body param, 
+            // and keep adding lines untill we encounter a line that ends with "]]"
+            let bodyParam = null;
+            if( line.indexOf("with_body [[") != -1 ) {
+                bodyParam = line.substring( line.indexOf("with_body [[") + "with_body [[".length ).trim();
+                let bodyLines = [];
+                if( bodyParam.length > 0 ) {
+                    bodyLines.push( bodyParam );
+                }
+                let j = i+1;
+                let bodyEndFound = false;
+                for( ; j<lines.length; j++ ) {
+                    let bodyLine = lines[j];
+                    if( bodyLine.indexOf("]]") != -1 ) {
+                        bodyEndFound = true;
+                        bodyLines.push( bodyLine.substring( 0, bodyLine.indexOf("]]") ) );
+                        break;
+                    }
+                    bodyLines.push( bodyLine );
+                }
+                if( bodyEndFound ) {
+                    bodyParam = bodyLines.join("\n").trim();
+                }
+            }
+
+            fCalls.push( {
+                name: funcCall ,
+                params: params,
+                body: bodyParam
+                }
+            );
+        }
+        
+    }
+
+    let fCalls2 = [];
+    for( let f=0; f<fCalls.length; f++) {
+
+        let fCall = fCalls[f];
+        //find interface for fCall.name
+        //console.log("Looking for interface for function call: ", JSON.stringify( fCall,null,2 ) );
+
+        let matchingInterface = null;
+        for( let i=0; i<interfaces.length; i++ ) {
+            let thisInterface = interfaces[i];
+            //let fullName = thisInterface.domain + "." + thisInterface.name;
+            if( (thisInterface.domain + "." + thisInterface.name) == fCall.name ) {
+                matchingInterface = thisInterface;
+                break;
+            }
+        }
+
+        if( matchingInterface ) {
+
+            let params2 = null;
+            if( fCall.params && fCall.params.length > 0 ) {
+                params2 = {};
+                //Params have to match order, but how.
+                //Answer, all params in interface in same array, but with type info
+
+                let iPathParams = matchingInterface.path_params || {};
+                let iQueryParams = matchingInterface.query_params || {};
+                let iFunParams = matchingInterface.params || {};
+                let iPathParamKeys = Object.keys( iPathParams );
+                let iQueryParamKeys = Object.keys( iQueryParams );
+                let iFunParamKeys = Object.keys( iFunParams );
+
+                let allParam = [];
+                for( let p=0; p<iPathParamKeys.length; p++ ) {
+                    let object = iPathParams[ iPathParamKeys[p] ];
+                    allParam.push( 
+                        { 
+                            name: iPathParamKeys[p], 
+                            type: "path",
+                            dataType: object.type 
+                        }
+                    );
+                }
+                for( let p=0; p<iQueryParamKeys.length; p++ ) {
+                    let object = iQueryParams[ iQueryParamKeys[p] ];
+                    allParam.push( 
+                        { 
+                            name: iQueryParamKeys[p], 
+                            type: "query",
+                            dataType: object.type,
+                            value: null
+                        }
+                    );
+                }
+                for( let p=0; p<iFunParamKeys.length; p++ ) {
+                    let object = iFunParams[ iFunParamKeys[p] ];
+                    allParam.push(
+                        {
+                            name: iFunParamKeys[p],
+                            type: "function",
+                            dataType: object.type,
+                            value: null
+                        }
+                    );
+                }
+
+                for( let fci=0; fci<fCall.params.length && fci<allParam.length; fci++ ) {
+                
+                    let paramValue = fCall.params[fci];
+                    let paramType = allParam[fci].dataType;
+                    
+
+                    paramValue = typifyValue( paramValue, paramType );
+                    allParam[fci].value = paramValue;
+
+                    params2[allParam[fci].name] = allParam[fci];
+                }
+            }
+            if( fCall.body ) {
+                params2 = params2 || {};
+                params2["@body"] = { value: fCall.body };
+            }
+
+            fCalls2.push( {
+                name: fCall.name,
+                params: params2,
+                interface: matchingInterface
+                //interface: foundInterface
+            } );
+        }
+        else {
+            console.log("No matching interface found for function call: ", fCall.name );
+        
+            fCalls2.push( {
+                name: fCall.name,
+                error: true,
+                detail: "not found"
+                //interface: foundInterface
+            } );            
+        }
+
+    }
+
+    return fCalls2;
+
+}
+
+function generateFunctionIfText_function( skill, useSeparator = false ) {
+    let interfaceText = "";
+    
+    
+
+    interfaceText += "@" + skill.domain + "." + skill.name+"( ";
+
+    let paramsExist = false;
+    if( skill.params ) {
+        
+        let p=0;
+        for (let paramName in skill.params ) {
+            let param = skill.params[ paramName ];
+            let field = paramName;
+            if( param.isRequired ) {
+                field = "*" + field;
+            }
+            if( param.type != "string" ) {
+                field += "{" + param.type + "}";
+            }
+
+            if( p>0 ) { interfaceText += ", ";}
+            interfaceText += " <" + field + ">";
+            paramsExist = true;
+            p++;
+        }
+    }
+
+    interfaceText += " )\n";
+
+    interfaceText += "Description: " + skill.description + "\n";
+
+    if( useSeparator ) {
+        return  interfaceText + separator + afterPadding ;
+    }
+    return interfaceText + afterPadding;    
+}
+
+
+function paramToText( paramName, paramObj ) {
+    let field = paramName;
+    if( paramObj.isRequired ) {
+        field = "*" + field;
+    }
+    if( paramObj.type != "string" ) {
+        field += "{" + paramObj.type + "}";
+    }
+    if( paramObj.type == "string" && paramObj.options) {
+        field += "[" + paramObj.options.join("|") + "]";
+    }    
+    return "<" + field + ">";
+}
+
+function generateFunctionIfText_apiWrapper(skill, useSeparator = false ) {
+
+    let interfaceText = "";
+
+    if(skill.response_type && !skill.response_type.includes("json") && skill.type == "api-wrapper") {
+        //interfaceText += "Unsupported! - " + skill.name+"() - API function with unsupported response type '" + skill.response_type + "'.\n" + afterPadding;
+        console.log ("Unsupported api response type: " + skill.response_type);
+        return "";
+    }    
+
+    interfaceText += "@" + skill.domain + "." + skill.name + "( ";
+    let paramsExist = false;
+
+    if( skill.path_params ) {
+        
+        let i = 0;
+        for (let paramName in skill.path_params ) {
+            if(i>0) { interfaceText += ","; }
+            i++;
+
+            let paramText = paramToText( paramName, skill.path_params[ paramName ] );
+
+            interfaceText += " " + paramText;
+            paramsExist = true;
+        }
+    }
+
+    if( skill.query_params ) {
+
+        let i=0;
+        for (let paramName in skill.query_params ) {
+            if(i>0) { interfaceText += ","; }
+            i++;
+
+            let paramText = paramToText( paramName, skill.query_params[ paramName ] );
+
+            interfaceText += " " + paramText;
+            paramsExist = true;
+        }
+    }    
+
+    interfaceText += " )";
+
+    if( skill.request_body ) {
+
+        if( skill.request_body ) {
+            interfaceText += " with_body ";
+        }
+
+        interfaceText += "{ ";
+        let bodyObj = skill.request_body;
+        if(skill.response_type && skill.response_type.includes("json")) {
+            let bodyKeys = Object.keys( bodyObj );
+            for( let b=0; b<bodyKeys.length; b++) {
+                let key = bodyKeys[b];
+                let field = bodyObj[key];
+                if(b>0) {
+                    interfaceText += ",";
+                }
+                let mandatory = "";
+                if( field.required )  {
+                    mandatory = "*";
+                }
+                interfaceText += " " + mandatory + key + ": " + field.type;
+            }
+
+            interfaceText += " }\n";
+
+        }
+        else {
+            interfaceText += "{ ?unsupported body? } \n";
+        }
+
+        //interfaceText += padLines2( JSON.stringify( skill.request_body, null, 2 )) + "\n";
+    }    
+    else {
+        interfaceText += "\n";
+    }
+
+    interfaceText += "Description: " + skill.description + "\n";    
+
+    if( useSeparator ) {
+        return separator + interfaceText + afterPadding;
+    }
+    return interfaceText + afterPadding;
+
+}
+
+
+function generateFunctionIfText(skill, separator = false) {
+    if( skill.type == "api-wrapper") {
+        return generateFunctionIfText_apiWrapper( skill, separator );
+    }
+    else if( skill.type == "function") {
+        return generateFunctionIfText_function( skill, separator );
+    }
+    return null;
+}
+
+
+
+function formatFunctionCallResults( fCalls ) {
+
+    let output = "";
+
+    for( let f=0; f<fCalls.length; f++ ) {
+
+        if( fCalls[f].error  ) {
+            output += `Function call: ${fCalls[f].name}( ???? ) ${fCalls[f].detail}\n`;
+
+            //fuzzy matches to propose
+            continue;
+        }
+
+        let params = "";
+        if( fCalls[f].params ) {
+            let paramKeys = Object.keys( fCalls[f].params );
+            for( let p=0; p<paramKeys.length; p++ ) {
+                if(p>0) params += ", ";
+                let key = paramKeys[p];
+                let value = fCalls[f].params[key].value;
+                let dataType = fCalls[f].params[key].dataType;
+                if( dataType === "string") {
+                    value = `"${value}"`;
+                }
+                //params += `${key}: ${value} `;
+                params += `${value} `;
+            }
+        }
+        output += `Function call: ${fCalls[f].name}( ${ params  }) \n`;
+
+        let outputExpected = false || fCalls[f].interface.returns;
+
+        if( outputExpected ) output += "Returned: \n";
+      
+        let fCall = fCalls[f];
+        let result = fCall.result;
+
+        if( outputExpected ) output += result + "\n\n";
+
+        //console.log("Result of ", fCall.name, ": ", JSON.stringify( result, null, 2 ) );
+    }
+
+    //output = converter.formatFunctionCallResults( fCalls );
+
+    return output;
+
+}
+
+
+// Case sensitivity preference: atfunc is case-insensitive for AI text parsing
+export const caseSensitive = false;
+
+export { generateFunctionIfText, getFunctionCallsFromText, formatFunctionCallResults };