#include "FiveWin.ch"
#include "hbcurl.ch"
#ifdef __XHARBOUR__
#define hb_hHasKey( h, k ) HHasKey( h, k )
#endif
//----------------------------------------------------------------------------//
CLASS TGemini
DATA cKey INIT ""
DATA cModel INIT "gemini-2.0-flash"
DATA cResponse
DATA cUrl INIT "https://generativelanguage.googleapis.com/v1beta/models"
DATA cUploadUrl INIT "https://generativelanguage.googleapis.com/upload/v1beta/files"
DATA hCurl
DATA nError INIT 0
DATA nHttpCode INIT 0
DATA nTemperature INIT 0
METHOD New( cKey, cModel )
METHOD Send( uContent, cPrompt, bCallback )
METHOD End()
METHOD GetValue()
METHOD UploadFile( cFileName, lDeleteAfter )
METHOD GetTokens( cBuffer )
ENDCLASS
//----------------------------------------------------------------------------//
METHOD New( cKey, cModel ) CLASS TGemini
if Empty( cKey )
::cKey = GetEnv( "GEMINI_API_KEY" )
else
::cKey = cKey
endif
if ! Empty( cModel )
::cModel = cModel
endif
if Val( SubStr( Curl_Version_Info()[ 1 ], 1, RAt( ".", Curl_Version_Info()[ 1 ] ) - 1 ) ) - 8.10 > 0.2
MsgAlert( "Please use an updated curl DLL" )
endif
::hCurl = curl_easy_init()
return Self
//----------------------------------------------------------------------------//
METHOD End() CLASS TGemini
curl_easy_cleanup( ::hCurl )
::hCurl = nil
return nil
//----------------------------------------------------------------------------//
METHOD GetValue() CLASS TGemini
local hResponse, uValue
if ! Empty( ::cResponse )
hb_jsonDecode( ::cResponse, @hResponse )
endif
if hb_isHash( hResponse )
if hb_hHasKey( hResponse, "error" )
uValue = "API Error: " + hResponse[ "error" ][ "message" ] + " (Code: " + hb_ntos( hResponse[ "error" ][ "code" ] ) + ")"
elseif hb_hHasKey( hResponse, "candidates" ) .and. Len( hResponse[ "candidates" ] ) > 0
TRY
uValue = hResponse[ "candidates" ][ 1 ][ "content" ][ "parts" ][ 1 ][ "text" ]
CATCH
uValue = "Error: Unexpected response structure"
END
else
uValue = "Error: No candidates in response"
endif
else
uValue = "Error: Invalid response format"
endif
return uValue
//----------------------------------------------------------------------------//
METHOD Send( uContent, cPrompt, bCallback ) CLASS TGemini
local aHeaders, cJson, hRequest := {=>}, hContents := { => }, hGenerationConfig
local cFileUri, cMimeType, lIsFile := .F., cUrlEndpoint
local aFiles, nI, aParts := {}, cFileNameToUpload, cTempFile
if Empty( cPrompt )
cPrompt = "what is this or solve this"
endif
if hb_isArray( uContent )
aFiles = uContent
for nI = 1 to Len( aFiles )
if hb_isChar( aFiles[ nI ] ) .and. File( aFiles[ nI ] )
cFileNameToUpload = aFiles[ nI ]
cTempFile = nil
if Lower( Right( aFiles[ nI ], 3 ) ) == "prg"
cTempFile = hb_FNameMerge( hb_FNameDir( aFiles[ nI ] ), hb_FNameName( aFiles[ nI ] ), "txt" )
hb_FCopy( aFiles[ nI ], cTempFile )
cFileNameToUpload = cTempFile
elseif Lower( Right( aFiles[ nI ], 2 ) ) == "ch"
cTempFile = hb_FNameMerge( hb_FNameDir( aFiles[ nI ] ), hb_FNameName( aFiles[ nI ] ), "txt" )
hb_FCopy( aFiles[ nI ], cTempFile )
cFileNameToUpload = cTempFile
endif
cFileUri = ::UploadFile( cFileNameToUpload, !Empty( cTempFile ) )
if Empty( cFileUri )
if !Empty( cTempFile ) .and. File( cTempFile )
hb_FileDelete( cTempFile )
endif
return "Error uploading file: " + aFiles[ nI ]
endif
do case
case Lower( Right( aFiles[ nI ], 3 ) ) == "png"
cMimeType = "image/png"
case Lower( Right( aFiles[ nI ], 3 ) ) $ "jpg|jpeg"
cMimeType = "image/jpeg"
case Lower( Right( aFiles[ nI ], 3 ) ) == "pdf"
cMimeType = "application/pdf"
case Lower( Right( aFiles[ nI ], 3 ) ) == "txt"
cMimeType = "text/plain"
case Lower( Right( aFiles[ nI ], 3 ) ) == "csv"
cMimeType = "text/csv"
case Lower( Right( aFiles[ nI ], 3 ) ) == "prg"
cMimeType = "text/plain"
case Lower( Right( aFiles[ nI ], 2 ) ) == "ch"
cMimeType = "text/plain"
otherwise
if !Empty( cTempFile ) .and. File( cTempFile )
hb_FileDelete( cTempFile )
endif
return "Unsupported file type: " + aFiles[ nI ]
endcase
AAdd( aParts, { "fileData" => { "fileUri" => cFileUri, "mimeType" => cMimeType } } )
if !Empty( cTempFile ) .and. File( cTempFile )
hb_FileDelete( cTempFile )
endif
else
return "Invalid file in array: " + aFiles[ nI ]
endif
next
lIsFile = .T.
elseif hb_isChar( uContent ) .and. File( uContent )
lIsFile = .T.
cFileNameToUpload = uContent
cTempFile = nil
if Lower( Right( uContent, 3 ) ) == "prg"
cTempFile = hb_FNameMerge( hb_FNameDir( uContent ), hb_FNameName( uContent ), "txt" )
hb_FCopy( uContent, cTempFile )
cFileNameToUpload = cTempFile
elseif Lower( Right( uContent, 2 ) ) == "ch"
cTempFile = hb_FNameMerge( hb_FNameDir( uContent ), hb_FNameName( uContent ), "txt" )
hb_FCopy( uContent, cTempFile )
cFileNameToUpload = cTempFile
endif
cFileUri = ::UploadFile( cFileNameToUpload, !Empty( cTempFile ) )
if Empty( cFileUri )
if !Empty( cTempFile ) .and. File( cTempFile )
hb_FileDelete( cTempFile )
endif
return ""
endif
do case
case Lower( Right( uContent, 3 ) ) == "png"
cMimeType = "image/png"
case Lower( Right( uContent, 3 ) ) $ "jpg|jpeg"
cMimeType = "image/jpeg"
case Lower( Right( uContent, 3 ) ) == "pdf"
cMimeType = "application/pdf"
case Lower( Right( uContent, 3 ) ) == "txt"
cMimeType = "text/plain"
case Lower( Right( uContent, 3 ) ) == "csv"
cMimeType = "text/csv"
case Lower( Right( uContent, 3 ) ) == "prg"
cMimeType = "text/plain"
case Lower( Right( uContent, 2 ) ) == "ch"
cMimeType = "text/plain"
otherwise
if !Empty( cTempFile ) .and. File( cTempFile )
hb_FileDelete( cTempFile )
endif
return "Unsupported file type"
endcase
AAdd( aParts, { "fileData" => { "fileUri" => cFileUri, "mimeType" => cMimeType } } )
if !Empty( cTempFile ) .and. File( cTempFile )
hb_FileDelete( cTempFile )
endif
endif
cUrlEndpoint = iif( hb_isBlock( bCallback ), ":streamGenerateContent", ":generateContent" )
curl_easy_setopt( ::hCurl, HB_CURLOPT_POST, .T. )
curl_easy_setopt( ::hCurl, HB_CURLOPT_URL, ::cUrl + "/" + ::cModel + cUrlEndpoint + "?key=" + ::cKey )
aHeaders := { "Content-Type: application/json" }
curl_easy_setopt( ::hCurl, HB_CURLOPT_HTTPHEADER, aHeaders )
curl_easy_setopt( ::hCurl, HB_CURLOPT_USERNAME, "" )
curl_easy_setopt( ::hCurl, HB_CURLOPT_DL_BUFF_SETUP )
curl_easy_setopt( ::hCurl, HB_CURLOPT_SSL_VERIFYPEER, .F. )
hContents[ "role" ] = "user"
if lIsFile
hRequest[ "contents" ] = { { "role" => "user", "parts" => aParts } }
if ! Empty( cPrompt )
AAdd( hRequest[ "contents" ], { "role" => "user", "parts" => { { "text" => cPrompt } } } )
endif
else
hContents[ "parts" ] = { { "text" => iif( hb_isChar( uContent ), uContent, cPrompt ) } }
hRequest[ "contents" ] = { hContents }
endif
hGenerationConfig = { "temperature" => ::nTemperature,;
"topK" => 40, "topP" => 0.95, "maxOutputTokens" => 8192,;
"responseMimeType" => "text/plain" }
hRequest[ "generationConfig" ] = hGenerationConfig
cJson = hb_jsonEncode( hRequest )
curl_easy_setopt( ::hCurl, HB_CURLOPT_POSTFIELDS, cJson )
if hb_isBlock( bCallback )
curl_easy_setopt( ::hCurl, HB_CURLOPT_WRITEFUNCTION, bCallback )
endif
::nError = curl_easy_perform( ::hCurl )
curl_easy_getinfo( ::hCurl, HB_CURLINFO_RESPONSE_CODE, @::nHttpCode )
if ::nError == HB_CURLE_OK
::cResponse = curl_easy_dl_buff_get( ::hCurl )
else
::cResponse = "CURL Error code " + Str( ::nError )
endif
return ::cResponse
//----------------------------------------------------------------------------//
METHOD UploadFile( cFileName, lDeleteAfter ) CLASS TGemini
local pCurl, aPost := {}, hHash
if hb_isPointer( pCurl := curl_easy_init() )
curl_easy_setopt( pCurl, HB_CURLOPT_CUSTOMREQUEST, "POST" )
curl_easy_setopt( pCurl, HB_CURLOPT_URL, ::cUploadUrl + "?key=" + ::cKey )
curl_easy_setopt( pCurl, HB_CURLOPT_FOLLOWLOCATION, .T. )
curl_easy_setopt( pCurl, HB_CURLOPT_DL_BUFF_SETUP )
curl_easy_setopt( pCurl, HB_CURLOPT_SSL_VERIFYPEER, .F. )
AAdd( aPost, { "file", hb_jsonEncode( { "display_name" => cFileName } ) } )
AAdd( aPost, { nil, cFileName } )
curl_easy_setopt( pCurl, HB_CURLOPT_MIMEPOST, aPost )
if ( ::nError := curl_easy_perform( pCurl ) ) == HB_CURLE_OK
hHash = hb_jsonDecode( ::cResponse := curl_easy_dl_buff_get( pCurl ) )
else
MsgAlert( "curl error: " + AllTrim( Str( ::nError ) ) )
endif
curl_easy_cleanup( pCurl )
endif
if hb_isHash( hHash )
#ifndef __XHARBOUR__
if hb_hHasKey( hHash, "file" ) .and. hb_hHasKey( hHash[ "file" ], "uri" )
#else
if HHasKey( hHash, "file" ) .and. HHasKey( hHash[ "file" ], "uri" )
#endif
return hHash[ "file" ][ "uri" ]
endif
endif
if lDeleteAfter .and. File( cFileName )
hb_FileDelete( cFileName )
endif
return ""
//----------------------------------------------------------------------------//
METHOD GetTokens( cBuffer ) CLASS TGemini
local hResponse, cValue := ""
if Left( cBuffer, 1 ) == ","
cBuffer = SubStr( cBuffer, 2 )
endif
hb_jsonDecode( cBuffer, @hResponse )
if ! Empty( hResponse )
if ValType( hResponse ) == "A" // Streaming response (array of chunks)
if hb_hHasKey( hResponse[ 1 ], "error" )
cValue = "API Error: " + hResponse[ 1 ][ "error" ][ "message" ] + " (Code: " + hb_ntos( hResponse[ 1 ][ "error" ][ "code" ] ) + ")"
elseif hb_hHasKey( hResponse[ 1 ], "candidates" ) .and. Len( hResponse[ 1 ][ "candidates" ] ) > 0
TRY
cValue = hResponse[ 1 ][ "candidates" ][ 1 ][ "content" ][ "parts" ][ 1 ][ "text" ]
CATCH
cValue = "Error: Unexpected streaming response structure"
END
else
cValue = "Error: No candidates in streaming response"
endif
elseif hb_isHash( hResponse ) // Non-streaming response
if hb_hHasKey( hResponse, "error" )
cValue = "API Error: " + hResponse[ "error" ][ "message" ] + " (Code: " + hb_ntos( hResponse[ "error" ][ "code" ] ) + ")"
elseif hb_hHasKey( hResponse, "candidates" ) .and. Len( hResponse[ "candidates" ] ) > 0
TRY
cValue = hResponse[ "candidates" ][ 1 ][ "content" ][ "parts" ][ 1 ][ "text" ]
CATCH
cValue = "Error: Unexpected response structure"
END
else
cValue = "Error: No candidates in response"
endif
else
cValue = "Error: Invalid response format in streaming buffer"
endif
endif
return cValue
//----------------------------------------------------------------------------//
#ifdef __XHARBOUR__
function HB_FNAMEDIR( cFileName )
local nLastSlash := Max( RAt( "\", cFileName ), RAt( "/", cFileName ) )
if nLastSlash > 0
return Left( cFileName, nLastSlash )
endif
return ""
function HB_FNAMENAME( cFileName )
local cName := cFileName
local nLastSlash := Max( RAt( "\", cFileName ), RAt( "/", cFileName ) )
local nLastDot
if nLastSlash > 0
cName = SubStr( cFileName, nLastSlash + 1 )
endif
nLastDot = RAt( ".", cName )
if nLastDot > 0
cName = Left( cName, nLastDot - 1 )
endif
return cName
function HB_FCOPY( cSource, cDest )
local hSource, hDest, nBytes, nRead, aBuffer := {}
if hb_isPointer( hSource := FOpen( cSource, "rb" ) )
if hb_isPointer( hDest := FOpen( cDest, "wb" ) )
while ! hb_feof( hSource )
nRead := FRead( aBuffer, 1, 1024, hSource )
FWrite( aBuffer, 1, nRead, hDest )
end
FClose( hDest )
endif
FClose( hSource )
endif
return nil
function HB_FILEDELETE( cFileName )
if File( cFileName )
return FErase( cFileName )
endif
return nil
#endif
