File size: 14,637 Bytes
c922f8b |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 |
"""
Step-by-step verification of GAIA components
This script tests each component individually to identify issues
"""
import os
import sys
import time
import logging
import traceback
from typing import Dict, Any, List
# Configure logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger("verify_components")
class ComponentVerifier:
"""Verifies each component of the GAIA system step by step"""
def __init__(self):
self.results = {}
self.env_vars_set = False
self.supabase_connected = False
def verify_environment(self):
"""Verify environment variables are set"""
try:
logger.info("Checking environment variables...")
required_vars = ["OPENAI_API_KEY", "SUPABASE_URL", "SUPABASE_KEY"]
missing = []
for var in required_vars:
if not os.environ.get(var):
missing.append(var)
if missing:
logger.error(f"Missing required environment variables: {', '.join(missing)}")
return False
logger.info("All required environment variables are set")
self.env_vars_set = True
return True
except Exception as e:
logger.error(f"Error checking environment variables: {e}")
return False
def verify_imports(self):
"""Verify that all necessary modules can be imported"""
try:
logger.info("Verifying imports...")
# 1. Try importing OpenAI
try:
from openai import OpenAI
logger.info("OpenAI module imported successfully")
self.results["openai_import"] = True
except Exception as e:
logger.error(f"Failed to import OpenAI: {e}")
self.results["openai_import"] = False
# 2. Try importing Supabase
try:
from supabase import create_client
logger.info("Supabase module imported successfully")
self.results["supabase_import"] = True
except Exception as e:
logger.error(f"Failed to import Supabase: {e}")
self.results["supabase_import"] = False
# 3. Try importing agent.config
try:
from agent.config import get_memory_config
logger.info("Agent config module imported successfully")
self.results["agent_config_import"] = True
except Exception as e:
logger.error(f"Failed to import agent.config: {e}")
self.results["agent_config_import"] = False
# 4. Try importing memory module
try:
from memory.supabase_memory import (
SupabaseMemory,
ConversationMemory,
ResultCache,
WorkingMemory
)
logger.info("Memory module imported successfully")
self.results["memory_import"] = True
except Exception as e:
logger.error(f"Failed to import memory module: {e}")
self.results["memory_import"] = False
# 5. Try importing memory fix
try:
from memory.fix_supabase_tables import apply_monkey_patch, ensure_tables_exist
logger.info("Memory fix module imported successfully")
self.results["memory_fix_import"] = True
except Exception as e:
logger.error(f"Failed to import memory fix module: {e}")
self.results["memory_fix_import"] = False
# 6. Try importing agent.graph
try:
from agent.graph import create_agent_graph, run_agent_graph
logger.info("Agent graph module imported successfully")
self.results["agent_graph_import"] = True
except Exception as e:
logger.error(f"Failed to import agent.graph: {e}")
self.results["agent_graph_import"] = False
# 7. Try importing agent
try:
from agent.agent import GAIAAgent
logger.info("GAIAAgent imported successfully")
self.results["agent_import"] = True
except Exception as e:
logger.error(f"Failed to import GAIAAgent: {e}")
self.results["agent_import"] = False
# 8. Try importing tools
try:
from tools.web_tools import duckduckgo_search
logger.info("Web tools imported successfully")
self.results["web_tools_import"] = True
except Exception as e:
logger.error(f"Failed to import web tools: {e}")
self.results["web_tools_import"] = False
return True
except Exception as e:
logger.error(f"Error verifying imports: {e}")
return False
def verify_supabase_connection(self):
"""Verify connection to Supabase"""
if not self.env_vars_set:
logger.error("Environment variables not verified, skipping Supabase connection test")
return False
try:
logger.info("Verifying Supabase connection...")
from supabase import create_client
supabase_url = os.environ.get("SUPABASE_URL")
supabase_key = os.environ.get("SUPABASE_KEY")
client = create_client(supabase_url, supabase_key)
# Try a simple query
response = client.table("_memory").select("count(*)", count="exact").execute()
count = response.count if hasattr(response, 'count') else 0
logger.info(f"Successfully connected to Supabase, found {count} records in _memory table")
self.supabase_connected = True
return True
except Exception as e:
logger.error(f"Failed to connect to Supabase: {e}")
logger.error(traceback.format_exc())
return False
def apply_supabase_fixes(self):
"""Verify and apply Supabase table fixes"""
if not self.supabase_connected:
logger.error("Supabase connection not verified, skipping table fixes")
return False
try:
logger.info("Applying Supabase table fixes...")
from memory.fix_supabase_tables import apply_monkey_patch, ensure_tables_exist
# Ensure tables exist
ensure_tables_exist()
logger.info("Successfully ensured all required tables exist")
# Apply monkey patch
apply_monkey_patch()
logger.info("Successfully applied monkey patch for Supabase tables")
return True
except Exception as e:
logger.error(f"Failed to apply Supabase fixes: {e}")
logger.error(traceback.format_exc())
return False
def initialize_memory(self):
"""Initialize and test memory system"""
try:
logger.info("Initializing memory system...")
from memory.supabase_memory import SupabaseMemory
from agent.config import get_memory_config
# Get memory config
memory_config = get_memory_config()
memory_config["enabled"] = True
# Initialize memory
memory = SupabaseMemory(memory_config)
# Test basic operations
test_key = f"test_key_{int(time.time())}"
test_value = {"message": "Test value", "timestamp": time.time()}
# Store
memory.store(test_key, test_value)
logger.info(f"Successfully stored test value with key: {test_key}")
# Retrieve
retrieved = memory.retrieve(test_key)
if retrieved and retrieved.get("message") == "Test value":
logger.info("Successfully retrieved test value")
return True
else:
logger.error(f"Retrieved value doesn't match. Got: {retrieved}")
return False
except Exception as e:
logger.error(f"Failed to initialize memory: {e}")
logger.error(traceback.format_exc())
return False
def test_memory_subtypes(self):
"""Test all memory subtypes"""
try:
logger.info("Testing memory subtypes...")
from memory.supabase_memory import (
SupabaseMemory,
ConversationMemory,
ResultCache,
WorkingMemory
)
from agent.config import get_memory_config
# Initialize base memory
memory_config = get_memory_config()
memory_config["enabled"] = True
memory = SupabaseMemory(memory_config)
# Test session ID
session_id = f"test_session_{int(time.time())}"
# Test conversation memory
try:
conversation = ConversationMemory(memory, session_id)
conversation.add_message("user", "Test question")
conversation.add_message("assistant", "Test answer")
messages = conversation.get_messages()
if len(messages) >= 2:
logger.info("ConversationMemory working correctly")
self.results["conversation_memory"] = True
else:
logger.error(f"ConversationMemory not working correctly. Got {len(messages)} messages")
self.results["conversation_memory"] = False
except Exception as e:
logger.error(f"Error testing ConversationMemory: {e}")
self.results["conversation_memory"] = False
# Test result cache
try:
cache = ResultCache(memory)
cache_key = f"test_cache_{int(time.time())}"
cache.cache_result(cache_key, "Test cache result")
cached = cache.get_result(cache_key)
if cached == "Test cache result":
logger.info("ResultCache working correctly")
self.results["result_cache"] = True
else:
logger.error(f"ResultCache not working correctly. Got: {cached}")
self.results["result_cache"] = False
except Exception as e:
logger.error(f"Error testing ResultCache: {e}")
self.results["result_cache"] = False
# Test working memory
try:
working = WorkingMemory(memory, session_id)
working.store_intermediate_result("test_step", "Test intermediate result")
results = working.list_intermediate_results()
if results and any(r.get("step") == "test_step" for r in results):
logger.info("WorkingMemory working correctly")
self.results["working_memory"] = True
else:
logger.error(f"WorkingMemory not working correctly. Got: {results}")
self.results["working_memory"] = False
except Exception as e:
logger.error(f"Error testing WorkingMemory: {e}")
self.results["working_memory"] = False
# Overall result
return (self.results.get("conversation_memory", False) and
self.results.get("result_cache", False) and
self.results.get("working_memory", False))
except Exception as e:
logger.error(f"Failed to test memory subtypes: {e}")
logger.error(traceback.format_exc())
return False
def run_all_tests(self):
"""Run all verification tests in sequence"""
logger.info("=== STARTING COMPONENT VERIFICATION ===")
# Step 1: Verify environment variables
self.results["environment"] = self.verify_environment()
# Step 2: Verify imports
self.results["imports"] = self.verify_imports()
# Step 3: Verify Supabase connection
if self.results["environment"]:
self.results["supabase_connection"] = self.verify_supabase_connection()
else:
logger.warning("Skipping Supabase connection test due to environment variables issue")
self.results["supabase_connection"] = False
# Step 4: Apply Supabase fixes
if self.results["supabase_connection"]:
self.results["supabase_fixes"] = self.apply_supabase_fixes()
else:
logger.warning("Skipping Supabase fixes due to connection issue")
self.results["supabase_fixes"] = False
# Step 5: Initialize memory
if self.results["supabase_fixes"]:
self.results["memory_initialize"] = self.initialize_memory()
else:
logger.warning("Skipping memory initialization due to Supabase fixes issue")
self.results["memory_initialize"] = False
# Step 6: Test memory subtypes
if self.results["memory_initialize"]:
self.results["memory_subtypes"] = self.test_memory_subtypes()
else:
logger.warning("Skipping memory subtypes test due to initialization issue")
self.results["memory_subtypes"] = False
# Print summary
logger.info("\n=== COMPONENT VERIFICATION RESULTS ===")
for component, result in self.results.items():
status = "SUCCESS" if result else "FAILED"
logger.info(f"{component}: {status}")
# Return overall result
return all(self.results.values())
if __name__ == "__main__":
verifier = ComponentVerifier()
success = verifier.run_all_tests()
if success:
logger.info("\n✅ All components verified successfully!")
sys.exit(0)
else:
logger.error("\n❌ Component verification failed!")
sys.exit(1) |