feat(llm): add LLM gating

Author: AayushGTM6693

agent-manager/src/repository/agent_manager_repository.ts

@@ -24,6 +24,7 @@ export async function fetchAgentConfiguration(agentId: string): Promise<
           configurations: any[]
           agentIndex: number
           agentName: string
+          agentConfig: any
       }
     | undefined
 > {
@@ -46,6 +47,8 @@ export async function fetchAgentConfiguration(agentId: string): Promise<
             const instanceCount = Number(agentInstance.instance)
             const agentIndex = Number(agentInstance.index)
             const agentName = agentInstance.name
+            const agentConfig = (agentInstance as any).config || null
+
             const configurationsData = agentConfigurations.map(
                 (config: { id: string; type: string; data: JsonValue; action: JsonValue }) => ({
                     id: config.id,
@@ -55,7 +58,7 @@ export async function fetchAgentConfiguration(agentId: string): Promise<
                 })
             )
 
-            return { instanceCount, configurations: configurationsData, agentIndex, agentName }
+            return { instanceCount, configurations: configurationsData, agentIndex, agentName, agentConfig }
         }
     } catch (error: any) {
         console.log(`Error fetching agent configuration: ${error}`)

agent-node/.env.example

@@ -1,2 +1,3 @@
 TOKEN=
-WS_URL=ws://localhost:3001
+WS_URL=ws://localhost:3001
+GEMINI_API_KEY=

agent-node/package.json

@@ -18,6 +18,7 @@
     "description": "",
     "dependencies": {
         "@emurgo/cardano-serialization-lib-asmjs": "^11.5.0",
+        "@google/genai": "^1.13.0",
         "@types/ws": "^8.5.10",
         "axios": "^1.6.8",
         "bech32": "^2.0.0",
@@ -29,8 +30,8 @@
         "ws": "^8.18.0"
     },
     "devDependencies": {
-        "@types/luxon": "^3.4.2",
         "@eslint/js": "^9.4.0",
+        "@types/luxon": "^3.4.2",
         "@types/node-cron": "^3.0.11",
         "@types/websocket": "^1.0.10",
         "eslint": "8",

agent-node/src/constants/global.ts

@@ -3,9 +3,16 @@ import { IEventBasedAction } from '../types/eventTriger'
 export const globalState: {
     eventTriggerTypeDetails: IEventBasedAction[]
     agentName: string
+    systemPrompt:string
+    functionLLMSettings: Record<
+        string,
+        { enabled: boolean; userPrefText: string; prefs?: any }
+    >
 } = {
     eventTriggerTypeDetails: [],
     agentName: '',
+    systemPrompt:'',
+    functionLLMSettings: {}
 }
 
 export const globalRootKeyBuffer: { value: Buffer | null } = {

agent-node/src/executor/AgentRunner.ts

@@ -8,6 +8,7 @@ import { HdWallet } from 'libcardano'
 import { AgentWalletDetails } from '../types/types'
 import { globalState } from '../constants/global'
 import { EventContext } from './BaseFunction'
+import { LLMService } from '../service/LLMService'
 
 export class AgentRunner {
     executor: Executor
@@ -18,7 +19,61 @@ export class AgentRunner {
         this.executor = new Executor(null, managerInterface, txListener)
     }
 
-    invokeFunction(triggerType: TriggerType, instanceIndex: number, method: string, ...args: any) {
+    async invokeFunction(triggerType: TriggerType, instanceIndex: number, method: string, ...args: any) {
+        const extractedArgs = this.extractArgumentValues(args)
+        const shouldUseLLM = this.shouldUseLLMForFunction(method)
+
+          if (shouldUseLLM) {
+            console.log('[AgentRunner] LLM gating enabled for', method)
+            console.log(
+                '[AgentRunner] GEMINI_API_KEY present:',
+                !!process.env.GEMINI_API_KEY || !!process.env.GOOGLE_API_KEY
+            )
+            try {
+                const llm = new LLMService()
+                console.log(
+                    '[AgentRunner] functionLLMSettings:',
+                    JSON.stringify(globalState.functionLLMSettings, null, 2)
+                )
+                const userPrefText = this.getUserPreferenceText(method)
+                console.log(
+                    '[AgentRunner] user policy for',
+                    method,
+                    ':',
+                    userPrefText || '(empty)'
+                )
+                const structuredPrefs = {}
+                const decision = await llm.shouldExecuteFunction(
+                    method,
+                    extractedArgs,
+                    structuredPrefs,
+                    userPrefText,
+                    globalState.systemPrompt
+                )
+                if (!decision.should_execute) {
+                    const blocked = [
+                        {
+                            function: method,
+                            arguments: args,
+                            return: {
+                                operation: method,
+                                executed: false,
+                                blocked_by_llm: true,
+                                llm_reasoning: decision.reasoning,
+                                llm_confidence: decision.confidence,
+                                message: `LLM blocked: ${decision.reasoning}`,
+                                timestamp: new Date().toISOString(),
+                            },
+                        },
+                    ]
+                    saveTxLog(blocked, this.managerInterface, triggerType, instanceIndex)
+                    return
+                }
+            } catch (e) {
+                console.error(`LLM gating failed, continuing: ${e}`)
+            }
+        }
+
         this.executor.invokeFunction(method, ...args).then((result) => {
             saveTxLog(result, this.managerInterface, triggerType, instanceIndex)
         })
@@ -47,6 +102,27 @@ export class AgentRunner {
             })
         }
     }
+    
+      // LLM helpers
+    private shouldUseLLMForFunction(method: string): boolean {
+        const fnCfg = globalState.functionLLMSettings?.[method]
+        console.log('fncfg is', fnCfg)
+        return !!(fnCfg && fnCfg.enabled)
+    }
+
+    private getUserPreferenceText(method: string): string {
+        console.log(
+            `globalState function llm settings -> ${JSON.stringify(
+                globalState.functionLLMSettings || {}
+            )}`
+        )
+        return globalState.functionLLMSettings?.[method]?.userPrefText || ''
+    }
+
+    private extractArgumentValues(args: any[]) {
+        return args.map((a) => (a && typeof a === 'object' && 'value' in a ? a.value : a))
+    }
+
 
     async remakeContext(index: number) {
         const rootKey = loadRootKeyFromBuffer()

agent-node/src/index.ts

@@ -71,8 +71,61 @@ function connectToManagerWebSocket() {
     })
 
     const topicHandler = new RpcTopicHandler(managerInterface, txListener)
+
+      // LLM settings extractor from configurations
+    function applyFnSettingsFromConfigurations(message: any) {
+        try {
+            console.log('[INIT] Raw configurations:', JSON.stringify(message?.configurations, null, 2))
+        } catch {}
+        if (!message?.configurations) return
+        globalState.functionLLMSettings = {}
+        message.configurations.forEach((cfg: any) => {
+            const act = cfg?.action || {}
+            if (act.function_name) {
+                globalState.functionLLMSettings[act.function_name] = {
+                    enabled: !!act.llm_enabled,
+                    userPrefText: act.llm_user_preferences_text || '',
+                    prefs: act.llm_preferences || undefined,
+                }
+            }
+        })
+        console.log('[INIT] LLM settings for:', Object.keys(globalState.functionLLMSettings))
+    }
+
     rpcChannel.on('event', (topic, message) => {
+        // initial payload containing configs
+        if (topic === 'initial_config') {
+            if (message.agentConfig?.system_prompt) {
+                globalState.systemPrompt = message.agentConfig.system_prompt
+                console.log('[INIT] System prompt loaded')
+            }
+            applyFnSettingsFromConfigurations(message)
+            return
+        }
+
+         // config updates from manager
+        if (topic === 'config_updated') {
+            applyFnSettingsFromConfigurations(message)
+             if (message.agentConfig?.system_prompt) {
+                globalState.systemPrompt = message.agentConfig.system_prompt
+                console.log('[INIT] System prompt loaded')
+            }
+        }
+
         if (topic == 'instance_count') {
+            // load system prompt if present
+            if (message.agentConfig?.system_prompt) {
+                globalState.systemPrompt = message.agentConfig.system_prompt
+                console.log('[INIT] System prompt loaded')
+            }
+            if (message.config?.system_prompt) {
+                globalState.systemPrompt = message.config.system_prompt
+                console.log('Loaded system prompt:', globalState.systemPrompt.slice(0, 80) + '...')
+            }
+
+            // ensure LLM prefs set
+            applyFnSettingsFromConfigurations(message)
+            
             globalRootKeyBuffer.value = message.rootKeyBuffer
             globalState.agentName = message.agentName
             Array(message.instanceCount)

agent-node/src/service/LLMService.ts

@@ -0,0 +1,123 @@
+import "dotenv/config"
+import { GoogleGenAI } from "@google/genai";
+
+const ai = new GoogleGenAI({});
+
+export class LLMService {
+
+    private apiKey:string
+
+    constructor (){
+this.apiKey = process.env.GEMINI_API_KEY || ""
+if(!this.apiKey){
+    console.warn("no gemini api key")
+}
+    }
+
+
+
+    async shouldExecuteFunction(
+           functionName: string,
+        functionArgs: any[],
+        structuredPreferences:any,
+        userPreferenceText: any ,
+        systemPrompt:string
+
+
+    ):Promise<{
+        should_execute:boolean,
+        confidence:number
+        reasoning:string
+    }> {
+
+        if(!this.apiKey){
+
+        console.log("llm not configured")
+        return {
+should_execute: true,
+                confidence: 0.5,
+                reasoning: 'LLM not configured, default allow'
+        }
+    }
+
+    try {
+        const prompt = this.buildPrompt(functionName, functionArgs,  structuredPreferences,
+        userPreferenceText ,
+        systemPrompt)
+        console.log("asking llm")
+const response:any = await ai.models.generateContent({
+    model: "gemini-2.5-flash",
+    contents: prompt,
+  });
+  console.log("response from gemini",response.text);
+//   todo return repsonse object with parsing
+
+const decision = this.extractJson(response.text)
+console.log('after parsing', decision)
+return {
+    should_execute:decision.should_execute,
+    confidence:decision.confidence,
+    reasoning:decision.reasoning
+}
+    }
+    catch (error:any){
+        console.error("llm failed, the error is this:", error)
+        return {
+            should_execute:true,
+            confidence: 0.6,
+            reasoning: `LLM service bhayena lol: ${error.message}`
+        }
+    }
+    
+    }
+ private buildPrompt(functionName: string, functionArgs: any[],  structuredPreferences:any,
+        userPreferenceText: any ,
+        systemPrompt:string){
+    const baseSystemP = systemPrompt || "you are an cardano autonomous agent"
+    const context = structuredPreferences && Object.keys(structuredPreferences).length ?  `\nContext:\n${JSON.stringify(structuredPreferences, null, 2)} `: ""
+    const userPolicy = userPreferenceText ? `\nUser Policy:\n${userPreferenceText}` : ''
+    console.log("userpolicy is: ", userPolicy)
+    console.log("context is empty aaile chai: ", context)
+       
+            return ` ${baseSystemP}
+
+FUNCTION TO EXECUTE: ${functionName}
+Args: ${JSON.stringify(functionArgs)}${context}${userPolicy}
+
+Analyze this call strictly against "User Policy".
+Return ONLY JSON:
+{"should_execute": true/false, "confidence": 0.0-1.0, "reasoning": "brief"}
+
+`
+ }
+
+
+
+
+    
+
+
+ extractJson(text: string): any {
+    // Remove code block markers if present
+    const cleaned = text.replace(/```json|```/g, '').trim();
+    // Find the first { and last }
+    const start = cleaned.indexOf('{');
+    const end = cleaned.lastIndexOf('}');
+    if (start !== -1 && end !== -1) {
+        const jsonString = cleaned.substring(start, end + 1);
+        try {
+            return JSON.parse(jsonString);
+        } catch (e) {
+            console.error('JSON parse error:', e, jsonString);
+        }
+    }
+    return {
+         should_execute: false,
+        confidence: 0.0,
+        reasoning: 'Failed to parse LLM response'
+    };
+}
+}
+
+
+

agent-node/src/utils/agent.ts

@@ -56,7 +56,20 @@ export function saveTxLog(
             }
             if (mainLog.return) {
                 txLog.result = mainLog.return
-                txLog.txHash = mainLog.return.hash
+                if((mainLog.return as any).blocked_by_llm  === true){
+                    txLog.success = false
+                    txLog.message = 
+                        (mainLog.return as any).llm_reasoning ||
+                        (mainLog.return as any).message ||
+                        'LLM blocked execution'
+                } else if ((mainLog.return as any).hash){
+                    txLog.txHash = (mainLog.return as any).hash
+                    txLog.message = (mainLog.return as any).message || 'Function executed successfully'
+ 
+                } else {
+                    txLog.message = (mainLog.return as any).message || 'Function executed successfully'
+                }
+                
             } else if (mainLog.error) {
                 txLog.result = mainLog.error
                 txLog.message = mainLog.error && ((mainLog.error as Error).message ?? mainLog.error)
@@ -72,7 +85,20 @@ export function saveTxLog(
                     }
                     if (log.return) {
                         internalLog.result = log.return
-                        internalLog.txHash = log.return.hash
+                        if ((log.return as any).blocked_by_llm === true) {
+                            internalLog.success = false
+                            internalLog.message =
+                                (log.return as any).llm_reasoning ||
+                                (log.return as any).message ||
+                                'LLM blocked execution'
+                        } else if ((log.return as any).hash) {
+                            internalLog.txHash = (log.return as any).hash
+                            internalLog.message = (log.return as any).message || 'Function executed successfully'
+                        } else {
+                            internalLog.message = (log.return as any).message || 'Function executed successfully'
+                        }
+
+                        
                     } else if (log.error) {
                         internalLog.result = log.error
                         internalLog.message = log.error && (log.error.message ?? log.error)