agentnet 0.0.1

package/src/examples/def.js

@@ -0,0 +1,74 @@
+import { Agent,  NatsIO, Gemini } from "../index.js"
+
+const basicAgent = await Agent()
+.addIO(NatsIO({
+	servers: ['nats://localhost:4222']
+}), {
+	tasks: ['basicagent'],
+	handoffs: ['mathagents.*']
+})
+.withLLM(Gemini, {
+	model: 'gemini-2.0-flash',
+	systemInstruction: `
+		You are an traveler agency agent.
+		Your role is to answer about the traveler (user) reservation.
+	  `,
+	config: {
+		temperature: 0,
+		toolConfig: {
+			functionCallingConfig: {
+				mode: 'auto'
+			}
+		}
+	}	
+})
+.on('prompt', async (state, input) => {
+	return input
+})
+.compile()
+
+const mathAgent = await Agent()
+.addIO(NatsIO({
+	servers: ['nats://localhost:4222']
+}), {
+	tasks: ['mathagents.v1']
+})
+.withLLM(Gemini, {
+	model: 'gemini-2.0-flash',
+	systemInstruction: `
+		You are an traveler agency agent.
+		Your role is to answer about the traveler (user) reservation.
+	  `,
+	config: {
+		temperature: 0,
+		toolConfig: {
+			functionCallingConfig: {
+				mode: 'auto'
+			}
+		}
+	}	
+})
+.addDiscoverySchema({
+	name: 'math_agent',
+	type: 'function',
+	description: 'Solve the math problem',
+	  parameters: {
+		type: 'object',
+		properties: {
+		  question: {
+			type: 'string',
+			description: 'Math problem to solve',
+		  }
+		},
+		required: ['question']
+	  }
+})
+.on('prompt', async (state, input) => {
+	return input
+})
+.compile()
+
+const result = await basicAgent.query("How 2 + 2 is?")
+console.log(result)
+
+

package/src/examples/def2.js

@@ -0,0 +1,65 @@
+import { AgentLoader, AgentClient, NatsIO } from "../index.js"
+
+const agents = await AgentLoader('./src/examples/agents.yaml')
+
+const agentTravel = await agents.advancedTravelAgent
+agentTravel.tools.flightSearchTool.bind(async (state, input) => {
+    return { answer: "The fly is from New York to Los Angeles at 10:00 AM" }
+})
+await agentTravel.compile()
+
+const agentWeather = await agents.weatherAgent
+agentWeather.tools.weatherSearchTool.bind(async (state, input) => {
+    return { answer: "The weather in New York is sunny" }
+})
+await agentWeather.compile()
+
+const agentNews = await agents.newsAgent
+agentNews.tools.newsSearchTool.bind(async (state, input) => {
+    return { answer: "Latest news: AI is taking over!" }
+})
+await agentNews.compile()
+
+const agentCalculator = await agents.calculatorAgent
+agentCalculator.tools.calculationTool.bind(async (state, input) => {
+    return { answer: `The result of ${input.expression} is 42` }
+})
+await agentCalculator.compile()
+
+const agentTranslation = await agents.translationAgent
+agentTranslation.tools.translationTool.bind(async (state, input) => {
+    return { answer: `'${input.text}' translated to ${input.targetLanguage} is 'Hola Mundo'` }
+})
+await agentTranslation.compile()
+
+const agentCalendar = await agents.calendarAgent
+agentCalendar.tools.createEventTool.bind(async (state, input) => {
+    return { answer: `Event '${input.title}' created for ${input.startTime}` }
+})
+agentCalendar.tools.listEventsTool.bind(async (state, input) => {
+    return { answer: `Events for ${input.startDate}: Meeting at 10 AM` }
+})
+await agentCalendar.compile()
+
+const agentStockTicker = await agents.stockTickerAgent
+agentStockTicker.tools.stockPriceTool.bind(async (state, input) => {
+    return { answer: `The price of ${input.symbol} is $100` }
+})
+await agentStockTicker.compile()
+
+const io = NatsIO({
+    servers: ['nats://localhost:4222']
+})
+
+const agentClient = AgentClient()
+//const res = await agentClient.queryAgent(agentTravelInstance, "Find me a flight from New York to Los Angeles")
+//console.log(res)
+
+// Wait for 2 seconds before proceeding
+await new Promise(resolve => setTimeout(resolve, 2000));
+
+const res = await agentClient.queryIo(io, 'advancedTravelAgent', "Find me a flight from New York to Los Angeles. How is the weather in New York? Give me some news. Also create the birthday event for my friend tomorrow 09-05-2025. RETURN TO ME THE RESULTS")
+console.log(res)
+
+//const res = await agent.query("Find me a flight from New York to Los Angeles")
+//console.log(res)

package/src/examples/def3.js

@@ -0,0 +1,67 @@
+import { AgentLoaderFile, AgentClient, NatsIO, Bindings, Message, PostgresStore } from "../index.js"
+
+// NatsIO instance
+const io = NatsIO({
+    servers: ['nats://localhost:4222']
+})
+
+// Load the agents from the YAML file
+const agents = await AgentLoaderFile('./src/examples/agents-smartness.yaml', {
+    bindings: { [Bindings.NatsIO]: io, [Bindings.Postgres]: PostgresStore() }
+})
+
+// Entry point
+const agentSmartness = await agents.smartnessAgent
+await agentSmartness.compile()
+
+// Accomodation agent
+const agentAccomodation = await agents.accomodationAgent
+agentAccomodation.tools.getRoomsListTool.bind(async (state, input) => {
+    return { answer: "We have Double room with a view of the sea and a single room with a view of the pool, and a suite with a view of the city." }
+})
+agentAccomodation.tools.getRoomDetailTool.bind(async (state, input) => {
+    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." }
+})
+agentAccomodation.prompt(async (state, input) => {
+    state._accomodationAgent = true
+    return input
+})
+await agentAccomodation.compile()
+
+// Booking agent
+const agentBooking = await agents.bookingAgent
+agentBooking.tools.bookRoomTool.bind(async (state, input) => {
+    return { answer: "The room " + input.roomName + " has been booked for the dates " + input.checkinDate + " to " + input.checkoutDate + "." }
+})
+await agentBooking.compile()
+
+// Hotel review agent
+const agentHotelReview = await agents.hotelReviewAgent
+agentHotelReview.tools.getHotelReviewsTool.bind(async (state, input) => {
+    return { answer: "The hotel " + input.hotelName + " has a 4.5 star rating and a 9.2 out of 10 guest satisfaction score." }
+})
+await agentHotelReview.compile()
+
+// Pricing agent
+const agentPricing = await agents.pricingAgent
+agentPricing.tools.getPricingTool.bind(async (state, input) => {
+    return { answer: "The room " + input.roomName + " has a price of 200€ per night." }
+})
+await agentPricing.compile()
+
+// Wait for 2 seconds before proceeding in order to allow self discovery
+await new Promise(resolve => setTimeout(resolve, 2000))
+
+// Agent client
+const agentClient = AgentClient()   
+const message = new Message({
+    content: "What rooms do you have from 2025-05-25 to 2025-05-30 for 3 guests For the hotel Flora? Give me the review of the hotel Flora",
+    session: {
+        id: "67a71e42-a7d8-1db2-ad17-64e1c8546b21"
+    }
+})
+const res = await agentClient.queryIo(io, 'smartnessAgent', message)
+console.log("=======\n", res.getContent())
+console.log("=======\n", res.getSession())
+//const res2 = await agentClient.queryIo(io, 'smartnessAgent', "Quanto costa la camera doppia del Flora per il 10-05-2025 per due persone? Prenotala se costa meno di 100€ la camera double con vista mare per il 10-05-2025 al hotel Flora")
+//console.log("=======\n", res2)

package/src/examples/simple.js

@@ -0,0 +1,103 @@
+import { AgentLoaderJSON, Message, Bindings, PostgresStore } from "../index.js"
+
+const agentDefinition = {
+    "apiVersion": "smartagent.io/v1alpha1",
+    "kind": "AgentDefinition",
+    "metadata": {
+      "name": "accomodationAgent",
+      "namespace": "smartchat"
+    },
+    "spec": {
+      "store": {
+        "type": "Postgres",
+      },
+      "llm": {
+        "provider": "Gemini",
+        "model": "gemini-2.0-flash",
+        "systemInstruction": "You are a highly advanced accomodation manager agent. \nPrioritize clarity and helpfulness.\nUse tools effectively to gather information.\n",
+        "config": {
+          "temperature": 0.5,
+          "toolConfig": {
+            "functionCallingConfig": {
+              "mode": "auto"
+            }
+          }
+        }
+      },
+      "tools": [
+        {
+          "name": "getRoomsListTool",
+          "description": "Retrieves a list of available rooms based on criteria.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "checkinDate": {
+                "type": "string",
+                "description": "The check-in date."
+              },
+              "checkoutDate": {
+                "type": "string",
+                "description": "The check-out date."
+              },
+              "guests": {
+                "type": "integer",
+                "description": "Number of guests."
+              }
+            },
+            "required": [
+              "checkinDate",
+              "checkoutDate"
+            ]
+          }
+        },
+        {
+          "name": "getRoomDetailTool",
+          "description": "Retrieves detailed information about a specific room.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "roomName": {
+                "type": "string",
+                "description": "The name of the room."
+              }
+            },
+            "required": [
+              "roomName"
+            ]
+          }
+        }
+      ]
+    }
+  }
+
+// Load the agent definition
+const agents = await AgentLoaderJSON(agentDefinition, {
+    bindings: {
+        [Bindings.Postgres]: PostgresStore()
+    }
+})
+
+// Add the binding tools to the agent
+agents.accomodationAgent.tools.getRoomsListTool.bind(async (state, input) => {
+    return { answer: "We have Double room with a view of the sea and a single room with a view of the pool, and a suite with a view of the city." }
+})
+agents.accomodationAgent.tools.getRoomDetailTool.bind(async (state, input) => {
+    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." }
+})
+
+// Compile the agent
+const agentInstance = await agents.accomodationAgent.compile()
+const input = new Message("What rooms do you have from 2025-05-10 to 2025-05-15 for 2 guests?")
+
+const input2 = new Message({
+  content: "What rooms do you have from 2025-05-10 to 2025-05-15 for 2 guests?",
+  session: {
+    id: "67a71e42-a7d8-1db2-ad17-64e1c8546b21",
+    propertySetId: "123"
+  }
+})
+
+
+const result = await agentInstance.query(input2)
+
+console.log(result.getContent())

package/src/index.js

@@ -0,0 +1,115 @@
+import * as _Agent from "./agent/agent.js";
+import * as _AgentLoader from "./agent/agent-loader.js";
+import * as _AgentClient from "./agent/client.js";
+import _Gemini from "./llm/gemini.js";
+import _GPT from "./llm/gpt.js";
+import { 
+    redisStore, 
+    postgresStore, 
+    memoryStore,
+    session 
+} from "./store/store.js";
+
+export const AgentLoaderFile = _AgentLoader.AgentLoaderFile
+export const AgentLoaderJSON = _AgentLoader.AgentLoaderJSON
+
+export const Agent = _Agent.Agent
+export const AgentClient = _AgentClient.AgentClient
+export const LLMRuntime = {
+    GPT: _GPT,
+    Gemini: _Gemini
+}
+
+export const Gemini = _Gemini
+export const GPT = _GPT
+
+export const PostgresStore = postgresStore
+export const RedisStore = redisStore
+export const MemoryStore = memoryStore
+export const SessionStore = session
+
+import { connect } from "@nats-io/transport-node"
+export const NatsIO = (config) => {
+    let connected = false
+    let nc = null
+    return {
+        type: 'NatsIO',
+        connect: async () => {
+            if (connected) {
+                return nc
+            }
+            nc = await connect(config)
+            connected = true
+            return nc
+        },
+        query: async (target, message) => {
+            const nc = await this.connect()
+            return await nc.request(target, message.serialize(), {replyTo: target + '.reply'})
+        }
+    }
+}
+export const Bindings = {
+    NatsIO: 'NatsIO',
+    Postgres: 'Postgres',
+    Redis: 'Redis',
+    Memory: 'Memory'
+}
+
+export class Message {
+    #content 
+    #session
+    constructor(input) {
+        if (typeof input === 'string') {
+            this.#content = input
+        } else {
+            this.#content = input.content 
+            this.#session = input.session || {}
+        }
+    }
+    getContent() {
+        return this.#content
+    }
+    getSessionId() {
+        return this.#session.id || null
+    }
+    getSession() {
+        return this.#session
+    }
+    serialize() {
+        return JSON.stringify({
+            content: this.#content,
+            session: this.#session
+        })
+    }
+    deserialize(data) {
+        const parsed = JSON.parse(data)
+        this.#content = parsed.content 
+        this.#session = parsed.session || {}
+    }
+}
+
+export class Response {
+    #content
+    #session
+    constructor(output) {
+        this.#content = output.content
+        this.#session = output.session
+    }
+    getContent() {
+        return this.#content
+    }
+    getSession() {
+        return this.#session
+    }
+    serialize() {
+        return JSON.stringify({
+            content: this.#content,
+            session: this.#session
+        })
+    }
+    deserialize(data) {
+        const parsed = JSON.parse(data)
+        this.#content = parsed.content
+        this.#session = parsed.session
+    }
+}

package/src/llm/gemini.js

@@ -0,0 +1,155 @@
+import { GoogleGenAI } from '@google/genai'
+import { logger } from '../utils/logger.js'
+import { LLMError } from '../errors/index.js'
+
+const type = 'gemini' 
+
+const getClient = async function () {
+    try {
+        if (!process.env.GEMINI_API_KEY) {
+            throw new LLMError(
+                'GEMINI_API_KEY environment variable is not set',
+                'gemini'
+            );
+        }
+        
+        logger.debug('Initializing Gemini client');
+        return new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+    } catch (error) {
+        logger.error('Failed to initialize Gemini client', { error });
+        throw new LLMError(
+            `Failed to initialize Gemini client: ${error.message}`,
+            'gemini',
+            { originalError: error }
+        );
+    }
+}
+
+const callModel = async function (llmClientConfig, context) {
+    const client = context.client;
+    const toolsAndHandoffsMap = context.toolsAndHandoffsMap;
+    const conversation = context.conversation;
+    const input = {};
+    
+    Object.assign(input, llmClientConfig);
+    input['contents'] = conversation;
+
+    if (input.config !== undefined && input.tools !== undefined) {
+        input.config.tools = toolsAndHandoffsMap.tools;
+    } else if (toolsAndHandoffsMap.tools.length > 0) {
+        if (input.config == undefined) {
+            input.config = {};
+        }
+        input.config.tools = [{ functionDeclarations: toolsAndHandoffsMap.tools }];
+    }
+
+    logger.debug('Calling Gemini model', { 
+        model: input.model,
+        conversationLength: conversation.length,
+        toolsCount: toolsAndHandoffsMap.tools.length
+    });
+    
+    try {
+        const res = await client.models.generateContent(input);
+        logger.debug('Gemini response received', {
+            responseType: res.response?.candidates ? 'candidates' : 'unknown',
+            hasContent: !!res.response?.candidates?.[0]?.content
+        });
+        return res;
+    } catch (error) {
+        logger.error('Gemini API error', { 
+            error,
+            modelName: input.model
+        });
+        
+        throw new LLMError(
+            `Gemini API error: ${error.message}`,
+            'gemini',
+            {
+                statusCode: error.status || error.statusCode,
+                modelName: input.model
+            }
+        );
+    }
+}
+
+const onResponse = async function (state, conversation, toolsAndHandoffsMap, response) {
+    if (response.text !== undefined) {
+        logger.debug('Gemini response contains text, returning directly');
+        conversation.push({ role: 'model', parts: [{ text: response.text }] });
+        return response.text;
+    }
+    
+    logger.debug('Gemini response contains function calls', {
+        functionCallCount: response.functionCalls?.length || 0
+    });
+    
+    for (const toolCall of response.functionCalls) {
+        const args = toolCall.args;
+        const name = toolCall.name;
+        
+        logger.debug('Executing tool from Gemini', { 
+            toolName: name,
+            argsPreview: JSON.stringify(args).substring(0, 100)
+        });
+        
+        try {
+            if (!toolsAndHandoffsMap[name] || !toolsAndHandoffsMap[name].function) {
+                throw new Error(`Tool "${name}" not found or has no function implementation`);
+            }
+            
+            let result = await toolsAndHandoffsMap[name].function(conversation, state, args);
+            if (toolsAndHandoffsMap[name].type === 'handoff') {
+                const resultParsed = JSON.parse(result)
+                // Update state with the result
+                if (resultParsed.session) {
+                    for (const key of Object.keys(resultParsed.session)) {
+                        state[key] = resultParsed.session[key]
+                    }
+                }
+            }
+            
+            const function_response_part = {
+                name: name,
+                response: typeof result === 'string' ? { answer: result } : result
+            };
+            
+            // Append function call and result of the function execution to contents
+            conversation.push({ role: 'model', parts: [{ functionCall: toolCall }] });
+            conversation.push({ role: 'user', parts: [{ functionResponse: function_response_part }] });
+            
+            logger.debug('Tool execution successful', { toolName: name });
+        } catch (error) {
+            logger.error(`Error executing tool "${name}"`, { error });
+            // Return error as function response
+            const errorResponse = {
+                name: name,
+                response: { error: error.message }
+            };
+            
+            conversation.push({ role: 'model', parts: [{ functionCall: toolCall }] });
+            conversation.push({ role: 'user', parts: [{ functionResponse: errorResponse }] });
+        }
+    }
+    
+    return null;
+}
+
+const prompt = async function (conversation, formattedPrompt) {
+    logger.debug('Adding user prompt to conversation', {
+        promptPreview: formattedPrompt.substring(0, 100)
+    });
+    
+    conversation.push({
+        role: 'user',
+        parts: [{ text: formattedPrompt}]
+    });
+}
+
+export default {
+    type,
+    getClient,
+    prompt,
+    callModel,
+    onResponse
+}