agentnet 0.1.30 → 0.1.32

package/examples/direct-agent-usage.js

@@ -1,4 +1,4 @@
-import { Agent, GPT, Message, MemoryStore } from "../src/index.js"
+import { Agent, GPT, Gemini, Message, MemoryStore } from "../src/index.js"
 
 // Example: Creating an agent directly without using AgentLoader
 async function createAgentDirectly() {
@@ -9,8 +9,8 @@ async function createAgentDirectly() {
             namespace: "smartchat",
             description: "A highly advanced accommodation manager agent"
         })
-        .withLLM(GPT, {
-            model: "gpt-4o-mini",
+        .withLLM(Gemini, {
+            model: "gemini-2.5-flash",
             instructions: "You are a highly advanced accommodation manager agent. \nPrioritize clarity and helpfulness.\nUse tools effectively to gather information."
         })
         .withStore(MemoryStore(), {
@@ -20,7 +20,7 @@ async function createAgentDirectly() {
             maxRuns: 10,                    // Maximum number of LLM calls per query
             maxConversationLength: 10       // Maximum conversation history length
         })
-        .addTool({
+        /*.addTool({
             name: "get_rooms_list_tool",
             description: "Retrieves a list of available rooms based on criteria.",
             type: "function",
@@ -67,8 +67,12 @@ async function createAgentDirectly() {
             return { 
                 answer: "The Double room with a view of the sea has a king size bed, a private balcony, and a view of the sea." 
             }
-        })
+        })*/
         // Optional: Add prompt handler
+        .onLLMResponse(async (state, response, usage) => {
+            console.log("LLM response:", state, usage)
+            return response
+        })
         .prompt(async (state, formattedInput) => {
             console.log("Processing prompt:", formattedInput)
             return formattedInput

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentnet",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "type": "module",
   "description": "Agent library used by Smartness",
   "main": "src/index.js",

package/src/agent/agent-loader.js

@@ -301,18 +301,25 @@ function configureRunner(agentBuilder, runnerSpec) {
  * @returns {object} Agent interface
  */
 function createAgentInterface(agentBuilder, toolMap) {
-    return {
+    const agentInterface = {
         tools: toolMap,
         prompt: (callback) => {
             agentBuilder._config.on.prompt = callback;
+            return agentInterface;
         },
         response: (callback) => {
             agentBuilder._config.on.response = callback;
+            return agentInterface;
+        },
+        onLLMResponse: (callback) => {
+            agentBuilder._config.on.onLLMResponse = callback;
+            return agentInterface;
         },
         compile: async () => {
             return await agentBuilder.compile();
         }
     };
+    return agentInterface;
 }
 
 /**

package/src/agent/agent.js

@@ -13,7 +13,8 @@ import { logger } from "../utils/logger.js"
  */
 const DEFAULT_HOOKS = {
     prompt: async (state, formattedInput) => formattedInput,
-    response: async (state, conversation, result) => result
+    response: async (state, conversation, result) => result,
+    onLLMResponse: null // Optional: called after each LLM call with (state, response, usage)
 }
 
 /**
@@ -200,6 +201,10 @@ export function Agent() {
             
             // Event handlers validation
             Object.entries(config.on).forEach(([eventName, handler]) => {
+                // Skip null handlers (optional hooks like onLLMResponse)
+                if (handler === null) {
+                    return;
+                }
                 if (typeof handler !== 'function') {
                     throw new ConfigurationError(`Event handler for '${eventName}' must be a function`, { 
                         eventName, 
@@ -438,6 +443,25 @@ export function Agent() {
         return this;
     }
 
+    /**
+     * Sets the LLM response handler - called after each LLM API call
+     * @param {Function} handler - Handler function (state, response, usage) => void
+     *   - state: Current agent state
+     *   - response: Raw LLM response object
+     *   - usage: Normalized token usage { inputTokens, outputTokens, totalTokens, reasoningTokens, cachedTokens, provider, model, raw }
+     * @returns {Object} Agent builder for chaining
+     */
+    function onLLMResponse(handler) {
+        if (typeof handler !== 'function') {
+            throw new ConfigurationError("onLLMResponse handler must be a function", {
+                provided: typeof handler
+            });
+        }
+        
+        config.on.onLLMResponse = handler;
+        return this;
+    }
+
     /**
      * Sets agent metadata
      * @param {Object} metadata - Agent metadata
@@ -542,6 +566,7 @@ export function Agent() {
         bindTool,
         prompt,
         response,
+        onLLMResponse,
         compile,
         setMetadata,
         getToolsSchemas,

package/src/agent/executor.js

@@ -166,6 +166,8 @@ async function safeExecute(func, name, type, state, input, timeout = DEFAULT_TOO
  * @param {Object} api - LLM API
  * @param {Object} llmConfig - LLM configuration
  * @param {Object} runner - Runner configuration
+ * @param {Object} callbacks - Callback functions
+ * @param {Function} callbacks.onLLMResponse - Called after each LLM call with (state, response, usage)
  * @returns {Function} Executor function
  */
 export async function build(
@@ -174,7 +176,8 @@ export async function build(
 	agentName, 
 	api, 
 	llmConfig, 
-	runner
+	runner,
+	callbacks = {}
 ) {
 	const maxRuns = runner?.maxRuns || 10;
 	
@@ -238,7 +241,7 @@ export async function build(
 				}
 			}
 
-			if (run >= maxRuns) {
+			if (run > maxRuns) {
 				logger.warn(`Agent ${agentName} max over runs reached: ${run}/${maxRuns}`);
 				api.resetCalledTools();
 				const rawConversation = contents.getRawConversation();
@@ -287,6 +290,16 @@ export async function build(
 				
 				logger.debug(`LLM response received for agent ${agentName}`);
 				
+				// Call onLLMResponse callback if defined
+				if (callbacks.onLLMResponse) {
+					try {
+						const usage = api.extractUsage(response);
+						await callbacks.onLLMResponse(state, response, usage);
+					} catch (error) {
+						logger.warn(`Error in onLLMResponse callback for agent ${agentName}`, { error });
+					}
+				}
+				
 				// Process the response
 				const finished = await api.onResponse(state, contents, toolsAndHandoffsMap, response);
 				

package/src/agent/runtime.js

@@ -16,7 +16,7 @@ export async function AgentRuntime(agentConfig) {
         handoffs,
         io: ioInterfaces,
         discoverySchemas,
-        on: { prompt, response }
+        on: { prompt, response, onLLMResponse }
     } = agentConfig
     
     // Initialize IO runtime
@@ -38,7 +38,8 @@ export async function AgentRuntime(agentConfig) {
         agentName,
         llmApi,
         llmConfig,
-        runner
+        runner,
+        { onLLMResponse }
     )
 
     // Create task processing function

package/src/llm/base.js

@@ -28,6 +28,26 @@ export class BaseLLM {
     return config;
   }
 
+  /**
+   * Extracts and normalizes token usage from the LLM response
+   * @param {Object} response - The raw LLM response
+   * @returns {Object} Normalized usage object
+   */
+  extractUsage(response) {
+    // Default implementation returns empty usage
+    // Subclasses should override this
+    return {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      reasoningTokens: 0,
+      cachedTokens: 0,
+      provider: this.type,
+      model: null,
+      raw: null
+    };
+  }
+
   getCalledTools() {
     return this.calledTools;
   }

package/src/llm/gemini.js

@@ -33,6 +33,25 @@ class GeminiLLM extends BaseLLM {
     }
   }
 
+  /**
+   * Extracts and normalizes token usage from the Gemini response
+   * @param {Object} response - The raw Gemini response
+   * @returns {Object} Normalized usage object
+   */
+  extractUsage(response) {
+    const usage = response?.usageMetadata;
+    return {
+      inputTokens: usage?.promptTokenCount ?? 0,
+      outputTokens: usage?.candidatesTokenCount ?? 0,
+      totalTokens: usage?.totalTokenCount ?? 0,
+      reasoningTokens: usage?.thoughtsTokenCount ?? 0,
+      cachedTokens: 0, // Gemini doesn't report cached tokens
+      provider: this.type,
+      model: response?.modelVersion || null,
+      raw: usage || null
+    };
+  }
+
   /**
    * Calls the Gemini model with the provided configuration and context
    * @param {Object} llmClientConfig - Configuration for the Gemini model
@@ -64,8 +83,8 @@ class GeminiLLM extends BaseLLM {
     });
     
     try {
-      
       const res = await client.models.generateContent(input);
+
       logger.debug('Gemini response', res)
       logger.debug('Gemini response received', {
         responseType: res.response?.candidates ? 'candidates' : 'unknown',
@@ -197,6 +216,7 @@ export default {
   prompt: geminiLLM.prompt.bind(geminiLLM),
   callModel: geminiLLM.callModel.bind(geminiLLM),
   onResponse: geminiLLM.onResponse.bind(geminiLLM),
+  extractUsage: geminiLLM.extractUsage.bind(geminiLLM),
   getCalledTools: geminiLLM.getCalledTools.bind(geminiLLM), 
   resetCalledTools: geminiLLM.resetCalledTools.bind(geminiLLM)
 }

package/src/llm/gpt.js

@@ -38,6 +38,25 @@ class OpenAILLM extends BaseLLM {
 		return llmClientConfig;
 	}
 
+	/**
+	 * Extracts and normalizes token usage from the OpenAI response
+	 * @param {Object} response - The raw OpenAI response
+	 * @returns {Object} Normalized usage object
+	 */
+	extractUsage(response) {
+		const usage = response?.usage;
+		return {
+			inputTokens: usage?.input_tokens ?? 0,
+			outputTokens: usage?.output_tokens ?? 0,
+			totalTokens: usage?.total_tokens ?? 0,
+			reasoningTokens: usage?.output_tokens_details?.reasoning_tokens ?? 0,
+			cachedTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
+			provider: this.type,
+			model: response?.model || null,
+			raw: usage || null
+		};
+	}
+
 	/**
 	 * Calls the OpenAI model with the provided configuration and context
 	 * @param {Object} llmClientConfig - Configuration for the OpenAI model
@@ -61,6 +80,7 @@ class OpenAILLM extends BaseLLM {
 		//console.log(JSON.stringify(input, null, 2))
 		try {
 			const response = await client.responses.create(input);
+
 			logger.debug('OpenAI response received');
 			return response;
 		} catch (error) {
@@ -197,6 +217,7 @@ export default {
 	prompt: openaiLLM.prompt.bind(openaiLLM),
 	callModel: openaiLLM.callModel.bind(openaiLLM),
 	onResponse: openaiLLM.onResponse.bind(openaiLLM),
+	extractUsage: openaiLLM.extractUsage.bind(openaiLLM),
 	getCalledTools: openaiLLM.getCalledTools.bind(openaiLLM),
 	resetCalledTools: openaiLLM.resetCalledTools.bind(openaiLLM)
 }