agentnet 0.0.1

package/src/llm/gpt.js

@@ -0,0 +1,155 @@
+import OpenAI from 'openai'
+import { logger } from '../utils/logger.js'
+import { LLMError } from '../errors/index.js'
+
+const type = 'openai' 
+
+const getClient = async function () {
+	try {
+		if (!process.env.OPENAI_API_KEY) {
+			throw new LLMError(
+				'OPENAI_API_KEY environment variable is not set',
+				'openai'
+			);
+		}
+		
+		logger.debug('Initializing OpenAI client');
+		return new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+	} catch (error) {
+		logger.error('Failed to initialize OpenAI client', { error });
+		throw new LLMError(
+			`Failed to initialize OpenAI client: ${error.message}`,
+			'openai',
+			{ 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['tools'] = toolsAndHandoffsMap.tools
+	input['input'] = conversation
+	
+	logger.debug('Calling OpenAI model', { 
+		model: input.model,
+		conversationLength: conversation.length,
+		toolsCount: toolsAndHandoffsMap.tools.length
+	});
+	
+	try {
+		const response = await client.responses.create(input)
+		logger.debug('OpenAI response received');
+		return response
+	} catch (error) {
+		logger.error('OpenAI API error', { 
+			error,
+			modelName: input.model
+		});
+		
+		throw new LLMError(
+			`OpenAI API error: ${error.message}`,
+			'openai',
+			{
+				statusCode: error.status || error.statusCode,
+				modelName: input.model
+			}
+		);
+	}
+}
+
+const onResponse = async function (state, conversation, toolsAndHandoffsMap, response) {
+	if (response.output_text !== undefined && response.output_text.length > 0) {
+		logger.debug('OpenAI response contains text, returning directly');
+		conversation.push({ role: 'model', parts: [{ text: response.output_text }] });
+		return response.output_text
+	}
+
+	const reasoning = response.output.filter(x => x.type == 'reasoning')
+	const functionCalls = response.output.filter(x => x.type == 'function_call')
+	
+	logger.debug('OpenAI response processing', {
+		reasoningCount: reasoning.length,
+		functionCallCount: functionCalls.length
+	});
+	
+	for (const res of reasoning) {
+		conversation.push(res)
+	}
+
+	for (const toolCall of functionCalls) {
+		try {
+			const args = JSON.parse(toolCall.arguments)
+			const name = toolCall.name
+			
+			logger.debug('Executing tool from OpenAI', { 
+				toolName: name,
+				argsPreview: JSON.stringify(args).substring(0, 100),
+				callId: toolCall.call_id
+			});
+			
+			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)
+			conversation.push(toolCall)
+            if (toolsAndHandoffsMap[name].type === 'handoff') {
+                console.log("GPT HANDOFF onResponse", name, result)
+                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 resultString = typeof result == 'string' ? result : JSON.stringify(result)
+			
+			logger.debug('Tool execution successful', { 
+				toolName: name,
+				resultPreview: resultString.substring(0, 100)
+			});
+			
+			conversation.push({        
+				type: "function_call_output",
+				call_id: toolCall.call_id,
+				output: resultString
+			})
+		} catch (error) {
+			logger.error(`Error executing tool "${toolCall.name}"`, { error });
+			
+			// Add error as function output
+			conversation.push(toolCall);
+			conversation.push({
+				type: "function_call_output",
+				call_id: toolCall.call_id,
+				output: JSON.stringify({ error: error.message })
+			});
+		}
+	}
+	return null
+}
+
+const prompt = async function (conversation, formattedPrompt) {
+	logger.debug('Adding user prompt to conversation', {
+		promptPreview: formattedPrompt.substring(0, 100)
+	});
+	
+	conversation.push({
+		role: 'user',
+		content: formattedPrompt
+	})
+}
+
+export default {
+	type,
+	getClient,
+	prompt,
+	callModel,
+	onResponse
+}

package/src/store/store.js

@@ -0,0 +1,167 @@
+import { v4 as uuid } from 'uuid'
+import { createClient } from 'redis'
+import pg from 'pg'
+
+let config = {
+    user: process.env.PG_USER || 'postgres',
+    host: process.env.PG_HOST || 'localhost', 
+    database: process.env.PG_DATABASE || 'postgres',
+    password: process.env.PG_PASSWORD || 'password',
+    port: process.env.PG_PORT || 5433
+}
+
+if (process.env.PG_USE_SSL == 'true' || process.env.PG_USE_SSL == true) {
+    config.ssl = {
+      rejectUnauthorized: false
+    }
+}
+
+const pool = new pg.Pool(config)
+
+pool.on('error', err => {
+    console.log(new Date(), 'Lost Postgres connection', err)
+})
+
+export async function getClient() {
+    const client = await pool.connect()
+    return client
+}
+
+export function session (id) {
+	let state = {}
+	let conversation = []
+
+	return {
+		query: async function (agentInstance, input) {
+			return await agentInstance.query(state, conversation, input)
+		},
+		setState: function (_state) {
+			state = _state
+		},
+		mergeState: function (_state) {
+			Object.keys(_state).forEach((key) => {
+				state[key] = _state[key]
+			})
+		},		
+		getState: function () {
+			return state
+		},
+		trimConversation: function (elementsToKeep) {
+			conversation = conversation.slice(-elementsToKeep)
+			let additionalElementsToRemove = 0
+			for (const chatIndex in conversation) {
+				if (conversation[chatIndex].role !== 'user' || conversation[chatIndex].role == undefined) {
+					additionalElementsToRemove += 1
+				} else {
+					break
+				}
+			}
+			if (additionalElementsToRemove > 0) {
+				conversation = conversation.slice(additionalElementsToRemove)
+			}
+		},
+		setConversation: function (_conversation) {
+			conversation = _conversation
+		},	
+		getConversation: function () {
+			return conversation
+		},
+		load: async function (stateStore) {
+			const _state = await stateStore.get(id)
+			if (_state !== null) {
+				const parsedState = JSON.parse(_state)
+				conversation = parsedState.conversation || []
+				state = parsedState.state || {}
+				return {
+					conversation: conversation,
+					state: state
+				}
+			}
+			return {
+				conversation: [],
+				state: {}
+			}
+		},
+		dump: async function (stateStore) {
+			return await stateStore.set(id, JSON.stringify({
+				conversation: conversation,
+				state: state				
+			}))
+		},		
+	}
+}
+
+export function redisStore (_config = null) {
+	let client = null
+	let config = _config
+
+	return {
+		connect: async function () {
+			if (!client) {
+				client = createClient(config || { url: 'redis://localhost:6379' })			
+				client.connect()
+			}
+		},
+		disconnect: async function () {
+			if (client) {
+				await client.disconnect()
+				client = null
+			}
+		},
+		set: async function (key, value) {
+			return await client.set(key, value)
+		},
+		get: async function (key) {
+			return await client.get(key)
+		}
+	}
+}
+
+export function postgresStore (_config = null) {
+	let client = null
+	let config = _config
+
+	return {
+		connect: async function () {
+			if (!client) {
+				client = await getClient()
+			}
+		},
+		disconnect: async function () {
+			if (client) {
+				await client.end()
+				client = null
+			}
+		},
+		set: async function (key, value) {
+			const id = uuid()
+			return await client.query('INSERT INTO smartchat_agent.conversation_state (state_id, state, id) VALUES ($1,$2,$3) ON CONFLICT (state_id) DO UPDATE SET state_id=$1, state=$2', [key, value, id])
+		},
+		get: async function (key) {
+			const res = await client.query('SELECT state FROM smartchat_agent.conversation_state WHERE state_id=$1', [key])
+			if (res.rows.length == 1) {
+				return res.rows[0].state
+			}
+			if (res.rows.length > 1) {
+				throw 'Something went wrong at pg store'
+			}
+			return null
+		}
+	}
+}
+
+export function memoryStore () {
+	let state = {}
+
+	return {
+		connect: async function () {},
+		disconnect: async function () {},
+		set: async function (key, value) {
+			state[key] = value
+			return state[key]
+		},
+		get: async function (key) {
+			return state[key] || null
+		}	
+	}
+}

package/src/utils/logger.js

@@ -0,0 +1,209 @@
+/**
+ * Logging levels
+ */
+export const LogLevel = {
+  ERROR: 'error',
+  WARN: 'warn',
+  INFO: 'info',
+  DEBUG: 'debug',
+  TRACE: 'trace'
+};
+
+/**
+ * Default logger configuration
+ */
+const DEFAULT_CONFIG = {
+  level: LogLevel.INFO,
+  enableTimestamps: true,
+  enableColors: true,
+  redactSensitiveData: true,
+  sensitiveKeys: ['api_key', 'key', 'token', 'password', 'secret', 'credential'],
+  maxOutputLength: 1000
+};
+
+// ANSI color codes for console output
+const COLORS = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m'
+};
+
+/**
+ * Formats log message with timestamp and level
+ */
+function formatLogMessage(level, message, config) {
+  let output = '';
+  
+  // Add timestamp
+  if (config.enableTimestamps) {
+    const timestamp = new Date().toISOString();
+    output += config.enableColors ? `${COLORS.gray}${timestamp}${COLORS.reset} ` : `${timestamp} `;
+  }
+  
+  // Add log level
+  if (config.enableColors) {
+    const levelColor = {
+      [LogLevel.ERROR]: COLORS.red,
+      [LogLevel.WARN]: COLORS.yellow,
+      [LogLevel.INFO]: COLORS.green,
+      [LogLevel.DEBUG]: COLORS.blue,
+      [LogLevel.TRACE]: COLORS.gray
+    }[level] || COLORS.reset;
+    
+    output += `${levelColor}[${level.toUpperCase()}]${COLORS.reset} `;
+  } else {
+    output += `[${level.toUpperCase()}] `;
+  }
+  
+  // Add message
+  output += message;
+  
+  return output;
+}
+
+/**
+ * Redacts sensitive data in objects
+ */
+function redactSensitiveData(data, sensitiveKeys) {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+  
+  if (Array.isArray(data)) {
+    return data.map(item => redactSensitiveData(item, sensitiveKeys));
+  }
+  
+  // Clone the object to avoid modifying the original
+  const result = { ...data };
+  
+  for (const key in result) {
+    if (Object.prototype.hasOwnProperty.call(result, key)) {
+      // Check if key name contains any sensitive patterns
+      const isSensitive = sensitiveKeys.some(pattern => 
+        key.toLowerCase().includes(pattern.toLowerCase())
+      );
+      
+      if (isSensitive) {
+        // Redact the value
+        result[key] = '[REDACTED]';
+      } else if (typeof result[key] === 'object' && result[key] !== null) {
+        // Recursively process nested objects
+        result[key] = redactSensitiveData(result[key], sensitiveKeys);
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Safely stringifies objects for logging
+ */
+function safeStringify(obj, maxLength) {
+  try {
+    if (obj instanceof Error) {
+      return obj.stack || obj.message;
+    }
+    
+    if (typeof obj === 'object' && obj !== null) {
+      let str = JSON.stringify(obj, null, 2);
+      if (maxLength && str.length > maxLength) {
+        str = str.substring(0, maxLength) + '... [truncated]';
+      }
+      return str;
+    }
+    
+    return String(obj);
+  } catch (err) {
+    return `[Unstringifiable Object: ${err.message}]`;
+  }
+}
+
+/**
+ * Creates a logger instance
+ */
+export function createLogger(customConfig = {}) {
+  const config = { ...DEFAULT_CONFIG, ...customConfig };
+  
+  // Log level priority map
+  const levelPriority = {
+    [LogLevel.ERROR]: 0,
+    [LogLevel.WARN]: 1,
+    [LogLevel.INFO]: 2,
+    [LogLevel.DEBUG]: 3,
+    [LogLevel.TRACE]: 4
+  };
+  
+  /**
+   * Internal logging function
+   */
+  function log(level, message, data = {}) {
+    // Check if this log level should be shown
+    if (levelPriority[level] > levelPriority[config.level]) {
+      return;
+    }
+    
+    // Handle error objects
+    if (message instanceof Error) {
+      data.stack = message.stack;
+      message = message.message;
+    }
+    
+    // Redact sensitive data if configured
+    let processedData = data;
+    if (config.redactSensitiveData && typeof data === 'object') {
+      processedData = redactSensitiveData(data, config.sensitiveKeys);
+    }
+    
+    // Format the basic message
+    let logMessage = formatLogMessage(level, message, config);
+    
+    // Add contextual data if available
+    if (processedData && Object.keys(processedData).length > 0) {
+      logMessage += '\n' + safeStringify(processedData, config.maxOutputLength);
+    }
+    
+    // Output to console
+    switch (level) {
+      case LogLevel.ERROR:
+        console.error(logMessage);
+        break;
+      case LogLevel.WARN:
+        console.warn(logMessage);
+        break;
+      case LogLevel.INFO:
+        console.info(logMessage);
+        break;
+      default:
+        console.log(logMessage);
+    }
+  }
+  
+  return {
+    error: (message, data) => log(LogLevel.ERROR, message, data),
+    warn: (message, data) => log(LogLevel.WARN, message, data),
+    info: (message, data) => log(LogLevel.INFO, message, data),
+    debug: (message, data) => log(LogLevel.DEBUG, message, data),
+    trace: (message, data) => log(LogLevel.TRACE, message, data),
+    
+    // Allow changing configuration at runtime
+    setLevel: (level) => {
+      if (Object.values(LogLevel).includes(level)) {
+        config.level = level;
+      } else {
+        log(LogLevel.WARN, `Invalid log level: ${level}. Using ${config.level}`);
+      }
+    },
+    
+    // Get the current logger configuration
+    getConfig: () => ({ ...config })
+  };
+}
+
+// Create and export default logger
+export const logger = createLogger();