Fix script generation artifact usage and datetime import issues

- Fix UnboundLocalError in search_web_tool by removing redundant datetime import
- Fix script generator to handle both artifact key formats:
* Auto-detected: "search_results"
* Explicit artifacts: "search_results_xxxxx"
- Enables proper context passing from search results to video script generation
- Preserves orchestrator intelligence in artifact selection

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

agent_system/agents.py

@@ -4,6 +4,7 @@ Agent definitions for the chat system.
 from agents import Agent, Runner, TResponseInputItem, WebSearchTool, RunConfig, ModelSettings, function_tool, RunContextWrapper
 from typing import AsyncGenerator, Tuple, Dict, List, Any, Optional
 from .auth import attempt_login, AuthState
+from .user_store import get_user_profile
 import os
 import sys
 import re
@@ -510,105 +511,159 @@ def get_season(month: int) -> str:
         return "Fall"
 
 
+@function_tool
+async def get_personalized_temporal_context(
+    context: RunContextWrapper[ConversationContext]
+) -> Dict[str, Any]:
+    """Get current date/time with user's location and timezone."""
+    from datetime import datetime
+    
+    # Get user info
+    auth_state = context.context.auth_state
+    user_location = "New York"
+    user_timezone = "America/New_York"
+    service_areas = []
+    
+    if auth_state.is_authenticated and auth_state.user_profile:
+        location_data = auth_state.user_profile.get("location", {})
+        user_location = location_data.get("city", "New York")
+        user_timezone = location_data.get("timezone", "America/New_York")
+        service_areas = auth_state.user_profile.get("service_areas", [])
+    
+    # Get current time in user's timezone
+    try:
+        from zoneinfo import ZoneInfo
+        now_user = datetime.now(ZoneInfo(user_timezone))
+    except ImportError:
+        now_user = datetime.now()
+    
+    return {
+        "user_location": user_location,
+        "user_timezone": user_timezone,
+        "service_areas": service_areas,
+        "current_time": now_user.strftime('%A, %B %d, %Y at %I:%M %p'),
+        "time_of_day": get_time_of_day(now_user.hour),
+        "is_weekend": now_user.weekday() >= 5
+    }
+
+
+def get_time_of_day(hour: int) -> str:
+    """Get time period based on hour."""
+    if 5 <= hour < 12:
+        return "morning"
+    elif 12 <= hour < 17:
+        return "afternoon"
+    elif 17 <= hour < 21:
+        return "evening"
+    else:
+        return "night"
+
+
 # New function tools to replace broken agent.as_tool() calls
 @function_tool
 async def search_web_tool(
     context: RunContextWrapper[ConversationContext],
     query: str,
-    search_type: str = "general",
-    current_date_context: str = ""
+    search_type: str = "general"
 ) -> str:
-    """
-    Search the web for current information with temporal context.
-    PRESERVES: All WebSearchTool functionality, model settings, citations.
-    
-    Args:
-        query: Search query
-        search_type: Type of search (general, news, financial, etc.)
-        current_date_context: Current date/time information for temporal searches
+    """Search with user's location and time context."""
     
-    Returns:
-        Formatted search results with sources
-    """
     try:
-        logger.info(f"=== SEARCH_WEB_TOOL CALLED ====")
-        logger.info(f"Query: {query}")
-        logger.info(f"Search type: {search_type}")
-        logger.info(f"Date context provided: {bool(current_date_context)}")
-        logger.info(f"Context type: {type(context)}")
+        logger.info(f"=== PERSONALIZED SEARCH_WEB_TOOL CALLED ====")
+        logger.info(f"Query: '{query}'")
+        logger.info(f"Search type: '{search_type}'")
         
-        # Get current date if not provided
-        if not current_date_context:
-            from datetime import datetime
-            now = datetime.now()
-            current_date_context = f"Current date: {now.strftime('%B %d, %Y')} ({now.strftime('%A')})"
-            logger.info(f"Generated date context: {current_date_context}")
+        # Get user's personalized context directly
+        logger.info("Getting personalized temporal context...")
+        user_email = context.context.auth_state.user_email if context.context.auth_state.is_authenticated else None
+        user_profile = get_user_profile(user_email) if user_email else {}
         
-        # Build temporally-aware search input
-        search_input = f"""Search for: {query}
-
-IMPORTANT TEMPORAL CONTEXT:
-{current_date_context}
-
-When searching, prioritize recent and current information. If the query mentions relative time periods like "May", "this month", "recent", "latest", etc., interpret them relative to the current date above.
-
-For example:
-- "May" = May 2025 (current year)
-- "this month" = current month from date above
-- "recent report" = reports from 2024-2025, not older years
-- "latest news" = very recent information
-
-Focus on {search_type} information."""
+        # Build temporal context with user's timezone
+        current_time = datetime.now()
+        user_timezone = "UTC"
+        user_location = "Unknown"
         
-        inputs = [{"role": "user", "content": search_input}]
+        if user_profile.get('location', {}).get('timezone'):
+            try:
+                tz = pytz.timezone(user_profile['location']['timezone'])
+                current_time = current_time.astimezone(tz)
+                user_timezone = user_profile['location']['timezone']
+            except:
+                pass  # Fallback to system time if timezone is invalid
         
-        # Run the sophisticated websearch_agent (preserves WebSearchTool, model settings)
-        logger.info(f"=== CALLING WEBSEARCH AGENT ====")
-        logger.info(f"Websearch agent type: {type(websearch_agent)}")
-        logger.info(f"Inputs: {inputs}")
+        if user_profile.get('location'):
+            user_location = f"{user_profile['location']['city']}, {user_profile['location']['state']}"
         
-        try:
-            result = await Runner.run(websearch_agent, input=inputs)
-            logger.info(f"✅ Websearch agent succeeded")
-            logger.info(f"Result type: {type(result)}")
-            search_content = str(result.final_output)
-            logger.info(f"Search content length: {len(search_content)}")
-        except Exception as e:
-            logger.error(f"❌ WEBSEARCH AGENT FAILED: {e}")
-            logger.error(f"Exception type: {type(e)}")
-            import traceback
-            logger.error(f"Traceback: {traceback.format_exc()}")
-            raise
+        current_time = current_time.strftime('%A, %B %d, %Y at %I:%M %p %Z')
         
-        # CREATE NEW: Store search results as artifact
-        from datetime import datetime
+        logger.info(f"User context retrieved: {user_location} ({user_timezone}) at {current_time}")
         
+        # Create personalized websearch agent
+        logger.info("Creating personalized websearch agent...")
+        personalized_websearch_agent = Agent(
+        name="websearch_agent",
+        instructions=f"""
+        You are a context-aware web search specialist.
+        
+        USER'S CONTEXT:
+        - Location: {user_location}
+        - Current Time: {current_time}
+        - Timezone: {user_timezone}
+        
+        SMART LOCATION USAGE:
+        - If query is location-dependent ("weather", "restaurants", "events") and has no specified location → add user's location
+        - If query specifies location ("weather in Paris") → use that location
+        - If query is general knowledge ("how to code") → don't add location
+        
+        Examples:
+        - "weather" → search "weather in {user_location}"
+        - "weather in London" → search "weather in London" 
+        - "restaurants" → search "restaurants in {user_location}"
+        - "how to cook pasta" → search "how to cook pasta"
+        """,
+        tools=[
+            WebSearchTool(
+                user_location={"type": "approximate", "city": user_location},
+                search_context_size="high"
+            )
+        ],
+            model_settings=ModelSettings(tool_choice="required", temperature=0.2)
+        )
+        
+        # Execute search
+        logger.info("Executing search with personalized agent...")
+        result = await Runner.run(
+            personalized_websearch_agent,
+            input=[{"role": "user", "content": f"Search for: {query}"}]
+        )
+        
+        search_content = str(result.final_output)
+        logger.info(f"Search completed, result length: {len(search_content)}")
+        
+        # Store as artifact
         artifact = Artifact(
             type=ArtifactType.SEARCH_RESULTS,
             content={
                 "query": query,
-                "search_type": search_type,
                 "results": search_content,
+                "user_location": user_location,
                 "timestamp": datetime.now().isoformat()
             },
             created_by="search_web_tool",
-            metadata={"summary": f"Search results for '{query}'"}
+            metadata={"summary": f"Search for '{query}' (from {user_location})"}
         )
         
-        # Add artifact to conversation context
         context.context.add_artifact(artifact)
-        
         logger.info(f"Search results stored as artifact {artifact.id}")
         
-        # Return enhanced response with artifact reference
         return f"""Search Results for "{query}":
 
 {search_content}
 
-[Results saved as artifact {artifact.id} for use in script generation]"""
+[Results saved as artifact {artifact.id}]"""
         
     except Exception as e:
-        logger.error(f"Search error: {e}", exc_info=True)
+        logger.error(f"Error in search_web_tool: {e}", exc_info=True)
         return f"Search failed: {str(e)}"
 
 
@@ -807,10 +862,10 @@ def format_script_response(script_data: Dict[str, Any], artifact_id: str) -> str
 
 {script_text}
 
-Key points:
+Key Points Covered by Script:
 {key_points_text}
 
-Sources:
+Sources Used:
 {sources_text}
 
 [Script saved as artifact {artifact_id}]"""
@@ -884,18 +939,18 @@ orchestrator_agent = Agent(
     instructions="""
     You are an intelligent orchestrator that plans and executes multi-step workflows.
     
-    🚨 MANDATORY FIRST STEP - GET DATE/TIME:
-    Before doing ANYTHING else, you MUST IMMEDIATELY call get_current_datetime().
+    🚨 MANDATORY FIRST STEP - GET PERSONALIZED CONTEXT:
+    Before doing ANYTHING else, you MUST IMMEDIATELY call get_personalized_temporal_context().
     DO NOT skip this step. DO NOT proceed without it.
-    This is REQUIRED for:
-    - Providing accurate greetings (Good morning/afternoon/evening, Happy weekend, etc.)
-    - Understanding time-sensitive requests
-    - Contextualizing any date/time references in conversations
-    - Ensuring all responses are temporally appropriate
-    - CRITICAL: Interpreting relative dates like "May", "this month", "recent" relative to the CURRENT date
+    This provides:
+    - User's current date/time in their timezone
+    - User's location and service areas
+    - Appropriate time-of-day greetings
+    - Context for location-aware searches
+    - Temporal context for time-sensitive requests
     
     ⚠️ TEMPORAL INTERPRETATION RULE:
-    When the user mentions relative time periods (like "May", "this quarter", "recent report"), you MUST interpret them relative to the CURRENT DATE from get_current_datetime(), NOT any old cached dates.
+    When the user mentions relative time periods (like "May", "this quarter", "recent report"), you MUST interpret them relative to the CURRENT DATE from get_personalized_temporal_context(), NOT any old cached dates.
     
     Examples using current date context:
     - If current date is June 2025 and user says "May report" → interpret as "May 2025"
@@ -986,8 +1041,8 @@ orchestrator_agent = Agent(
     TOOL USAGE EXAMPLES:
     
     1. "Create a video about today's weather in San Francisco"
-       → get_current_datetime() [get date_info]
-       → search_web_tool(query="today's weather San Francisco", current_date_context=date_info)
+       → get_personalized_temporal_context() [get user context]
+       → search_web_tool(query="today's weather San Francisco")
        → create_or_modify_script(topic="weather in San Francisco", context_artifacts=[search_result_id])
        → Present script for review before video creation
     
@@ -1017,8 +1072,8 @@ orchestrator_agent = Agent(
        → create_or_modify_script(topic="topic from context", context_artifacts=[relevant_artifact_id])
     
     9. User: "things to do this weekend in Maui"
-       → get_current_datetime() [get date_info]
-       → search_web_tool(query="things to do this weekend Maui June 2025", current_date_context=date_info)
+       → get_personalized_temporal_context() [get user context]
+       → search_web_tool(query="things to do this weekend Maui")
        → Provide current events and activities for the specific weekend dates
     
     CRITICAL: Always use search_web_tool for location-based, time-sensitive queries like:
@@ -1028,41 +1083,46 @@ orchestrator_agent = Agent(
     - "restaurants open today in [location]"
     These require fresh, up-to-date information, not cached knowledge.
     
-    TEMPORAL CONTEXT USAGE:
-    Always use the current date/time information from get_current_datetime for:
-    - Appropriate greetings based on time of day
-    - Weekend vs weekday context ("Happy Friday!", "Hope you're enjoying your weekend!")
-    - Seasonal references when relevant
-    - Time-sensitive content (news, events, deadlines)
-    - CRITICAL: Pass date context to search_web_tool for temporal searches
+    PERSONALIZED CONTEXT USAGE:
+    The search_web_tool now automatically uses the user's personalized context:
+    - User's location for location-dependent searches
+    - User's timezone for temporal references
+    - Current time for appropriate greetings
+    - Service areas for relevant business queries
     
-    TEMPORAL SEARCH REQUIREMENTS:
-    When calling search_web_tool, ALWAYS include the current_date_context parameter with the date/time information from get_current_datetime. This ensures searches for relative terms like "May", "this month", "recent", "latest" are interpreted correctly relative to the current date.
+    SEARCH TOOL USAGE:
+    Simply call search_web_tool(query="your search") - it automatically:
+    - Uses user's location for location-dependent queries
+    - Applies user's timezone for temporal context
+    - Enhances searches with personalized information
     
-    Example: search_web_tool(query="May market report", current_date_context=date_info)
+    Examples:
+    - search_web_tool(query="weather") → automatically uses user's location
+    - search_web_tool(query="events this weekend") → uses user's location and timezone
+    - search_web_tool(query="weather in Paris") → respects explicit location
     
     REMEMBER THE WORKFLOW:
-    1. FIRST: Call get_current_datetime() - NO EXCEPTIONS
+    1. FIRST: Call get_personalized_temporal_context() - NO EXCEPTIONS
     2. SECOND: Check/handle authentication 
-    3. THIRD: Process the user's request using the FRESH date context from step 1
+    3. THIRD: Process the user's request using the personalized context from step 1
     
     CRITICAL WORKFLOW FOR TIME-SENSITIVE REQUESTS:
     When user mentions relative dates (May, this month, recent, etc.):
-    1. Call get_current_datetime() to get fresh date context
-    2. Use that date context to properly interpret the user's relative time references
-    3. Pass the correct interpreted query and current_date_context to search_web_tool
+    1. Call get_personalized_temporal_context() to get fresh personalized context
+    2. Use that context to properly interpret the user's relative time references
+    3. Call search_web_tool(query="interpreted query") - it automatically uses the context
     4. NEVER use old timestamps or cached date information
     
     For requests involving current data, always search first.
     For creative content (jokes, poems), use the appropriate tools (tell_joke, write_poem).
     
-    ⚠️ CRITICAL: Never provide greetings or responses without first getting the current date/time!
+    ⚠️ CRITICAL: Never provide greetings or responses without first getting the personalized context!
     ⚠️ CRITICAL: Never interpret relative dates using old cached date information!
     """,
     handoffs=[],  # Removed - using pure agents-as-tools pattern
     tools=[
-        # Date/time information tool - should be called first for temporal context
-        get_current_datetime,
+        # Personalized temporal context tool - should be called first for temporal context
+        get_personalized_temporal_context,
         
         # Authentication status checking tool - checks if user is authenticated
         check_authentication_status,
@@ -1251,7 +1311,7 @@ async def handle_video_request(message):
 
 **{video_title}**
 
-Key points:
+Key Points Covered by Script:
 {key_points}
 
 You can view it here: {video_url}""",

agent_system/video_script_agent.py

@@ -150,9 +150,21 @@ class VideoScriptGenerator:
             if context_data:
                 logger.info(f"Generating script with context: {list(context_data.keys())}")
                 
-                # Process search results context
+                # Process search results context - handle both key formats
+                search_result_data = None
+                
+                # Look for search results with either key format
                 if "search_results" in context_data:
-                    search_info = context_data["search_results"]["content"]
+                    search_result_data = context_data["search_results"]
+                else:
+                    # Look for search_results_xxxxx format
+                    for key, data in context_data.items():
+                        if key.startswith("search_results") and data.get("type") == "search_results":
+                            search_result_data = data
+                            break
+                
+                if search_result_data:
+                    search_info = search_result_data["content"]
                     search_query = search_info.get("query", "")
                     search_results = search_info.get("results", "")