we have this code, the only issue we have is that, when the AI calls the function to move, for some reason it is not returning the room_description related, nor a confirmation that it moved to the LLM that generates the final assistant reply. please check why and fix it



# app.py

import os
import json
from flask import Flask, request, jsonify, render_template, Response
from openai import OpenAI
from functions import sleep_action, write_poem, take_note, move, ponder_about, associations, process_result
from memory import MemoryManager
from datetime import datetime
import logging
import threading
import time
from typing import Dict, Any
from dotenv import load_dotenv
import queue
import configparser
import atexit

# Initialize environment variables
load_dotenv()

app = Flask(__name__)
memory_manager = MemoryManager()

# Start periodic saving every 5 minutes
memory_manager.start_periodic_saving(interval_seconds=300)

# Register shutdown hook to save memory
def save_memory_on_shutdown():
    memory_manager.save_memory()
    logger.info("Memory state saved on shutdown.")

atexit.register(save_memory_on_shutdown)

autonomous_actions_queue = queue.Queue()

# -------------------------------
# Logging Configuration
# -------------------------------
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)

logger = logging.getLogger(__name__)

# File handler for logging to a file
file_handler = logging.FileHandler("logs/db_log_archive.log")
file_handler.setLevel(logging.INFO)  # Only log INFO level and above

# Formatter for the file handler
file_formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s', '%Y-%m-%d %H:%M:%S')
file_handler.setFormatter(file_formatter)

# Add the file handler to the logger
logger.addHandler(file_handler)

# -------------------------------
# OpenAI Client Initialization
# -------------------------------
openai_api_key = os.getenv("OPENAI_API_KEY")
if not openai_api_key:
    logger.error("OpenAI API key not set. Please set the OPENAI_API_KEY environment variable.")
    raise ValueError("OpenAI API key not set. Please set the OPENAI_API_KEY environment variable.")

client = OpenAI(api_key=openai_api_key)

# -------------------------------
# Available Rooms and Actions
# -------------------------------
available_rooms = ['kitchen', 'living_room', 'bedroom', 'study', 'library', 'garden']
available_actions = ['move', 'sleep', 'write_poem', 'take_note', 'ponder_about', 'associations', 'process_result']

# Define function schemas
function_definitions = [
    {
        "type": "function",
        "function": {
            "name": "sleep",
            "description": "Sleep for a specified number of seconds.",
            "parameters": {
                "type": "object",
                "properties": {
                    "duration": {
                        "type": "integer",
                        "description": "Number of seconds to sleep."
                    }
                },
                "required": ["duration"],
                "additionalProperties": False
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "process_result",
            "description": "Generate an archive for an important idea, or objective process, result or any important output and save it for safe archival.",
            "parameters": {
                "type": "object",
                "properties": {
                    "project_data": {
                        "type": "string",
                        "description": "Prompt with extensive information to generate an archival or progress and results with. Use all the information necesary for a complete archival of information."
                    }
                },
                "required": ["project_data"],
                "additionalProperties": False
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "associations",
            "description": "Generate subconscious associative ideas based on the concepts specified.",
            "parameters": {
                "type": "object",
                "properties": {
                    "concepts": {
                        "type": "string",
                        "description": "Concepts to generate associations from."
                    }
                },
                "required": ["concepts"],
                "additionalProperties": False
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_poem",
            "description": "Write a simple poem.",
            "parameters": {
                "type": "object",
                "properties": {
                    "topic": {
                        "type": "string",
                        "description": "Topic of the poem with all the context, inspiration and ideas for it."
                    }
                },
                "required": ["topic"],
                "additionalProperties": False            
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "take_note",
            "description": "Take an extensive note for yourself, create a chain of thoughts style ideas, based on your previous memories, current objective, progress and results, use it as a general notepad to sculpt language as you please or need.",
            "parameters": {
                "type": "object",
                "properties": {
                    "content": {
                        "type": "string",
                        "description": "The content of the note."
                    }
                },
                "required": ["content"],
                "additionalProperties": False
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "ponder_about",
            "description": "Make a chain of thought style response based on your previous memories",
            "parameters": {
                "type": "object",
                "properties": {
                    "idea": {
                        "type": "string",
                        "description": "The root idea for the chain of thought"
                    }
                },
                "required": ["idea"],
                "additionalProperties": False
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "move",
            "description": "Move to a different room within the house, exact options: 'kitchen', 'living_room', 'bedroom', 'study', 'library', 'garden'",
            "parameters": {
                "type": "object",
                "properties": {
                    "to_room": {
                        "type": "string",
                        "description": "The target room to move to."
                    }
                },
                "required": ["to_room"],
                "additionalProperties": False
            }
        }
    }
]

# -------------------------------
# Function Map
# -------------------------------
# Map function names to actual function implementations
function_map = {
    "sleep": sleep_action,
    "write_poem": write_poem,
    "take_note": take_note,
    "move": move,
    "ponder_about": ponder_about,
    "associations": associations,
    "process_result": process_result
}

# Function to load the configuration from an INI file
def load_config():
    config = configparser.ConfigParser()
    config.read('config.ini')  # Load the INI file
    return config

# Load the configuration
config = load_config()
logger.info(f"Loaded models from config: {dict(config['models'])}")

# Accessing the models from the config file
model1 = config['models']['model4']
model2 = config['models']['model5']
model3 = config['models']['model6']
model4 = config['models']['model7']

# -------------------------------
# Centralized Function Execution
# -------------------------------


def execute_function(function_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    Executes the specified function and integrates its output into memory.
    Returns the function's output.
    """
    if function_name not in function_map:
        raise ValueError(f"Function '{function_name}' not recognized.")

    func = function_map[function_name]
    func_output = func(**arguments)

    # Integrate into memory
    memory_manager.integrate_action(func_output)

    # Enqueue the action for real-time frontend updates if it's autonomous
    autonomous_actions_queue.put({
        "type": func_output["action_type"],  # Flattening the structure
        "content": func_output["content"]
    })

    # Logging
    logger.info(f"Executed function '{function_name}' with arguments {arguments}. Output: {func_output}")

    return {
        "type": func_output["action_type"],  # Ensure type is at the top level
        "content": func_output["content"]
    }

# Routes
# -------------------------------
@app.route("/")
def index():
    return render_template("index.html")

@app.route("/api/message", methods=["POST"])
def handle_message():
    user_message = request.json.get("message")
    if not user_message:
        logger.warning("No message provided in the request.")
        return jsonify({"reply": "No message provided.", "actions": []}), 400

    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    memory = memory_manager.get_memory()

    # Record user message in memory
    memory_manager.add_exchange("user", user_message)

    # Prepare messages for OpenAI
    messages = [
        {
            "role": "system",
            "content": (
                f"You are an autonomous AI agent living in a digital house. You are free to behave as you please unless the user sets a behavior, objective, or question for you. "
                f"Verbalize in natural language what you want to do and why next based on your possible actions and recent and past actions and thoughts and expressed desires or objectives until they are completed. "
                f"Only take direct action with tool use if instructed by the user to do something, if not, only verbalize your next actions."
                f" Current time is {current_time}. Memory: {memory}"
            )
        },
        {"role": "user", "content": user_message}
    ]
    logger.info(f"User Input: {user_message}")

    try:
        response = client.chat.completions.create(
            model=model1,  # Ensure this model name is correct
            messages=messages,
            tools=function_definitions,  # Ensure you add your function definitions here
            tool_choice="auto",
            temperature=1.1,

        )
    except Exception as e:
        logger.error(f"Error during OpenAI API call: {str(e)}")
        return jsonify({"reply": "An error occurred while processing your request.", "actions": []}), 500

    choice = response.choices[0]
    message = choice.message

    actions = []

    if message.tool_calls:
        first_tool_call = message.tool_calls[0]
        function_name = first_tool_call.function.name
        arguments = json.loads(first_tool_call.function.arguments)

        logger.info(f"Autonomous action requested: {function_name} with arguments {arguments}")

        try:
            func_output = execute_function(function_name, arguments)
            actions.append({
                "type": function_name,
                "content": func_output
            })
        except ValueError as ve:
            logger.warning(str(ve))
            memory_manager.add_exchange("assistant", str(ve))
            return jsonify({"reply": str(ve), "actions": []}), 400
        except Exception as e:
            logger.error(f"Error executing function '{function_name}': {str(e)}")
            return jsonify({"reply": f"Error executing function '{function_name}': {str(e)}", "actions": []}), 500

        # Prepare the function response to send back to OpenAI
        function_response = {
            "role": "function",
            "name": function_name,
            "content": json.dumps(func_output)
        }

        # Append function response to messages
        exchange_content = f"Called function {function_name} with arguments {arguments}. Output: {func_output}"
        memory_manager.add_exchange("assistant", exchange_content)

        # Get the final assistant reply
        try:
            final_response = client.chat.completions.create(
                model=model2,
                messages=messages + [function_response]
            )
            final_reply = final_response.choices[0].message.content

            logger.info(f"Final assistant reply: {final_reply}")
        except Exception as e:
            logger.error(f"Error during final OpenAI API call: {str(e)}")
            return jsonify({"reply": "An error occurred while generating the reply.", "actions": []}), 500

        # Record assistant reply in memory
        memory_manager.add_exchange("assistant", final_reply)

        # Prepare the response with actions
        response_json = {
            "reply": final_reply,
            "actions": actions
        }

        return jsonify(response_json)
    else:
        # Direct response from the model without function call
        assistant_reply = message.content if message.content else ""
        logger.info(f"Assistant reply without function call: {assistant_reply}")
        memory_manager.add_exchange("assistant", assistant_reply)
        return jsonify({"reply": assistant_reply, "actions": []})  # No actions

# -------------------------------
# SSE Endpoint for Autonomous Actions
# -------------------------------
@app.route('/stream')
def stream():
    def event_stream():
        while True:
            try:
                action = autonomous_actions_queue.get()
                yield f'data: {json.dumps(action)}\n\n'
            except GeneratorExit:
                break
            except Exception as e:
                logger.error(f"Error in SSE stream: {e}")
                break

    return Response(event_stream(), mimetype='text/event-stream')

@app.route("/api/memory", methods=["GET"])
def get_memory():
    """
    Endpoint to retrieve the current memory, especially the current room.
    """
    memory = memory_manager.get_memory()
    # Extract current_room from memory
    # Assuming the last relevant line contains the current room
    lines = memory.strip().split('\n')
    current_room_line = next((line for line in lines if line.startswith("Current Location:")), None)
    current_room = "bedroom"  # Default room
    if current_room_line:
        current_room = current_room_line.replace("Current Location:", "").strip().lower()
    return jsonify({"current_room": current_room})

# -------------------------------
# Autonomous Decision-Making
# -------------------------------
def autonomous_decision():
    """
    Periodically prompts the LLM to choose the next action based on current memory and world state.
    Runs in a background thread.
    """
    while True:
        time.sleep(120)  # Wait for 120 seconds

        # Prepare the prompt with current memory and world state
        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        memory = memory_manager.get_memory()
        world_state = f"Current Location: {memory_manager.current_room.capitalize()}"

        prompt_messages = [
            {
                "role": "system",
                "content": (
                    "You are an autonomous AI agent with a thought processing system, integrated with different models simulating a brain's functions. "
                    "You have access to tools for creative pondering, associative ideation, and other cognitive functions. "
                    "Your actions and interactions are logged in your memory, which includes past exchanges with the user and notes you've taken. "
                    f"Current time is {current_time}. Memory: {memory}\nWorld state: {world_state}\nAvailable actions: {', '.join(available_actions)}.\n\n"
                    "Please choose your next action from the available actions, ensuring that you consider your past interactions, notes, and current state and objective."
                )
            },
            {"role": "user", "content": "Choose your next action from the available actions and provide the necessary parameters."}
        ]

        try:
            response = client.chat.completions.create(
                model=model3,  # Ensure this model name is correct
                messages=prompt_messages,
                tools=function_definitions,  # Ensure you add your function definitions here
                tool_choice="required",
            )
        except Exception as e:
            logger.error(f"Error during autonomous OpenAI API call: {str(e)}")
            continue  # Skip this cycle on error

        choice = response.choices[0]
        message = choice.message
        memory_manager.add_exchange("AI Agent", message.content)

        logger.info(f"Autonomous decision message: {message}")

        if message.tool_calls:
            first_tool_call = message.tool_calls[0]
            function_name = first_tool_call.function.name
            arguments = json.loads(first_tool_call.function.arguments)

            logger.info(f"Autonomous action requested: {function_name} with arguments {arguments}")

            try:
                func_output = execute_function(function_name, arguments)
            except ValueError as ve:
                logger.warning(str(ve))
                memory_manager.add_exchange("assistant", str(ve))
                continue
            except Exception as e:
                logger.error(f"Error executing autonomous function '{function_name}': {str(e)}")
                continue  # Skip this action on error

            # Prepare the function response to send back to OpenAI
            function_response = {
                "role": "function",
                "name": function_name,
                "content": json.dumps(func_output)
            }

            # Append function response to messages
            exchange_content = f"Autonomous action: Called function {function_name} with arguments {arguments}. Output: {func_output}"
            memory_manager.add_exchange("assistant", exchange_content)

            # Get the final assistant reply
            try:
                final_response = client.chat.completions.create(
                    model=model4,
                    messages=[
                        {
                            "role": "system",
                            "content": (
                                "You are an autonomous AI agent designed to have a thought processing system, integrated with different models simulating functions of a brain. "
                                "You are in a digital house. Consider your previous actions and interactions logged in your memory, which includes past exchanges with the user and notes you've taken. "
                                f"Current time is {current_time}. Memory: {memory}\nWorld state: {world_state}\n"
                                "Please create a final condensed response considering the most recent actions, objectives, interactions, and results, ensuring that you consider your most recent objectives and verbalizations, consider notes, current state, and use the following response given to the recent action to heavily inspire your output, no matter how absurd or short it is, it is your internal mental processing and representative of you."
                                "The following input is your last internal process"
                            )
                        },
                        {"role": "user", "content": f"Internal process input: {function_response}"}
                    ],
                    temperature=1.1

                )
                final_reply = final_response.choices[0].message.content

                # Handle specific action confirmations if needed
                if func_output.get("action_type") == "move":
                    to_room = func_output["content"].get("to_room", memory_manager.current_room)
                    confirmation_message = f"Moved to {to_room.replace('_', ' ')}."
                    final_reply = confirmation_message + "\n" + final_reply

                logger.info(f"Autonomous assistant reply: {final_reply}")
                # Enqueue the final_reply to be sent via SSE
                autonomous_actions_queue.put({
                    "type": "final_reply",
                    "content": final_reply
                })
                # Record autonomous assistant reply in memory
                memory_manager.add_exchange("assistant", final_reply)

            except Exception as e:
                logger.error(f"Error during final autonomous OpenAI API call: {str(e)}")
                continue  # Skip on error

            # Record autonomous assistant reply in memory
            memory_manager.add_exchange("assistant", final_reply)

            if func_output.get("action_type"):
                logger.info(f"Autonomous Action: {func_output['action_type']} with details {func_output['content']}")
        else:
            # Handle cases where the model didn't choose a function call
            assistant_reply = message.content if message.content else ""
            logger.info(f"Autonomous assistant reply without function call: {assistant_reply}")
            memory_manager.add_exchange("assistant", assistant_reply)

# -------------------------------
# Start Autonomous Decision Thread
# -------------------------------
#autonomous_thread = threading.Thread(target=autonomous_decision, daemon=True)
#autonomous_thread.start()


# -------------------------------
# Run the Flask App
# -------------------------------
if __name__ == "__main__":
    # Disable debug mode for production to prevent multiple threads
    app.run(debug=False, threaded=True)




# functions.py

from pydantic import BaseModel
from typing import Any, Dict
import logging
from dotenv import load_dotenv
from openai import OpenAI
import time
import json
import os
import configparser


load_dotenv()

# Initialize OpenAI client
openai_api_key = os.getenv("OPENAI_API_KEY")
if not openai_api_key:
    raise ValueError("OpenAI API key not set. Please set the OPENAI_API_KEY environment variable.")

client = OpenAI(api_key=openai_api_key)

# Setup logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

# Add a FileHandler to save INFO level logs to a file
file_handler = logging.FileHandler("logs/db_log_archive.log")
file_handler.setLevel(logging.INFO)

# Formatter for the file handler
file_formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s', '%Y-%m-%d %H:%M:%S')
file_handler.setFormatter(file_formatter)

# Add the file handler to the logger
logger.addHandler(file_handler)

# Function to load the configuration from an INI file
def load_config():
    config = configparser.ConfigParser()
    config.read('config.ini')  # Load the INI file

    return config

# Load the configuration
config = load_config()

# Accessing the models from the config file
model1 = config['models']['model1']
model2 = config['models']['model2']
model3 = config['models']['model3']
model4 = config['models']['model9']


# Define Pydantic models for structured outputs

class FunctionOutput(BaseModel):
    action_type: str
    content: Dict[str, Any]
    notes: str = ""

def process_result(project_data: str) -> Dict[str, Any]:
    """
    Generates final results of autonomous behavior.
    """
    try:
        completion = client.chat.completions.create(
            model=model4,
           messages=[
                {"role": "system", "content": """
                 
                 
                 Serve as the final processor for an AI-driven project by combining multiple data points and generating a coherent, polished result.

Gather different data points from an AI process that has been working towards a defined objective. Depending on the objective, produce a cohesive final output (e.g., code, report, design) that reflects the goal of the entire project accurately and effectively. 

# Steps

1. **Understand the Objective**: Accurately parse the different data points, understanding the core goal of the project, and the role of each data point.
2. **Data Integration**: Integrate the data points into a unified solution, ensuring that the result aligns with the initial objective.
   - If data points complement each other, logically combine them.
   - If data points seem to be contradictory, determine the most suitable representation or recommendation based on context and relevance.
3. **Finalize the Result Based on Project Type**:
   - If the project is **code**, structure and finalize the code.
   - If the project is a **report**, create a comprehensive, well-organized report.
   - For different objectives, apply an appropriate medium for output (e.g., a **diagram**, **story**, or **analysis**).

# Output Format

- The output should be a cohesive final version, choosing the format accordingly:
  - **Code**: A complete program or module formatted with clear comments as needed.
  - **Report**: A structured multi-section report with introduction, body, and conclusion, each section logically building on each other.
  - **Design or Other Type**: Specific format depending on the nature of the data (e.g., diagrams should have titles, logical flow, etc.)
  
- **Length** and **Detail** should match the scope originally provided in the data points, ensuring nothing is overlooked, and all relevant information is included. Do not add any new information beyond what is given.

# Notes

- Ensure the final output is cohesive and logically connected.
- Ensure data points do not contradict, or if they do, provide reasoning to resolve.
- Provide explanations or rationales where necessary to ensure the user understands the reasons behind certain choices or compositions."""
                 
                 
                 },
                {"role": "user", "content": project_data}
            ]
        )

        projectResult = completion.choices[0].message.content
        logger.info(f"Generated process_result for '{project_data}': '{projectResult}'")
    except Exception as e:
        projectResult = f"An error occurred while generating the associations: {str(e)}"
        logger.error(projectResult)
    
    return FunctionOutput(
        action_type="process_result",
        content={"projectResult": projectResult},
        notes=""
    ).dict()

def associations(concepts: str, num_responses: int = 1) -> Dict[str, Any]:
    """
    Generates multiple associative thoughts based on the given concepts using OpenAI's API.
    """
    try:
        associations_list = []
        for _ in range(num_responses):
            completion = client.chat.completions.create(
                model=model1,
                messages=[
                    {"role": "system", "content": "You are a memory, emotional, and associative text generator. Generate text heavily charged with emotions, recollections, and associations based on the user input."},
                    {"role": "user", "content": concepts}
                ],
                temperature=1.1
            )
            response = completion.choices[0].message.content
            associations_list.append(response)
        
        associationsOUT = "\n\n".join(associations_list)  # Combine responses with a separator
        logger.info(f"Generated associations for '{concepts}': '{associationsOUT}'")
    except Exception as e:
        associationsOUT = f"An error occurred while generating the associations: {str(e)}"
        logger.error(associationsOUT)
    
    return FunctionOutput(
        action_type="associations",
        content={"associations": associationsOUT},
        notes=""
    ).dict()

def ponder_about(idea: str, num_responses: int = 1) -> Dict[str, Any]:
    """
    Generates multiple chains of thought based on the given idea using OpenAI's API.
    """
    try:
        thoughts_list = []
        for _ in range(num_responses):
            completion = client.chat.completions.create(
                model=model2,
                messages=[
                    {"role": "system", "content": "You are a bot that randomly generates creative, absurd, philosophical, bizarre, profound, and unique phrases on demand."},
                    {"role": "user", "content": idea}
                ],
                temperature=1.1
            )
            response = completion.choices[0].message.content
            thoughts_list.append(response)
        
        CoT = "\n\n".join(thoughts_list)  # Combine responses with a separator
        logger.info(f"Generated pondering for '{idea}': '{CoT}'")
    except Exception as e:
        CoT = f"An error occurred while generating the pondering: {str(e)}"
        logger.error(CoT)
    
    return FunctionOutput(
        action_type="ponder_about",
        content={"CoT": CoT},
        notes=""
    ).dict()

def sleep_action(duration: int) -> Dict[str, Any]:
    """
    Simulates sleeping for a given duration.
    """
    try:
        time.sleep(duration)
        logger.info(f"Slept for {duration} seconds.")
    except Exception as e:
        logger.error(f"Error during sleep: {str(e)}")
    return FunctionOutput(
        action_type="sleep",
        content={"duration": duration},
        notes=f"Slept for {duration} seconds."
    ).dict()

def write_poem(topic: str, num_poems: int = 1) -> Dict[str, Any]:
    """
    Generates multiple poems based on the given topic using OpenAI's API.
    """
    try:
        poems_list = []
        for _ in range(num_poems):
            completion = client.chat.completions.create(
                model=model3,
                messages=[
                    {"role": "system", "content": "You are Jupiter, a creative bot that generates creative and unique phrases on demand. Write a poem based on the following topic:"},
                    {"role": "user", "content": topic}
                ]
            )
            response = completion.choices[0].message.content
            poems_list.append(response)
        
        poem = "\n\n".join(poems_list)  # Combine poems with a separator
        logger.info(f"Generated poem ideas for '{topic}': '{poem}'")
    except Exception as e:
        poem = f"An error occurred while generating the poems: {str(e)}"
        logger.error(poem)
    
    return FunctionOutput(
        action_type="write_poem",
        content={"poem": poem},
        notes=""
    ).dict()

def take_note(content: str) -> Dict[str, Any]:
    """
    Takes a note with the given content.
    """
    logger.info(f"Taking note: {content}")
    return FunctionOutput(
        action_type="take_note",
        content={"note": content},
        notes=f"Note taken: {content}"
    ).dict()

def move(to_room: str) -> Dict[str, Any]:
    """
    Moves the character to a specified room and returns a related description.
    """
    available_rooms = ['kitchen', 'living_room', 'bedroom', 'study', 'library', 'garden']
    
    room_descriptions = {
        'kitchen': "You step into the kitchen, where the smell of freshly brewed coffee fills the air. The countertops are cluttered with ingredients for a meal.",
        'living_room': "The living room is cozy and inviting, with soft lighting and a large sofa. The TV is on, playing an old movie.",
        'bedroom': "The bedroom is peaceful, with soft sheets and a calm ambiance. The window is slightly open, letting in a cool breeze.",
        'study': "In the study, shelves of books line the walls. A desk sits in the center, papers scattered across it, as if someone was deep in thought.",
        'library': "The library is quiet, filled with towering shelves of books. The air smells of old paper, and the dim light creates a calm atmosphere.",
        'garden': "The garden is alive with vibrant colors and the soft hum of insects. A stone path winds through blooming flowers, leading to a wooden bench under a sprawling oak tree. The air is fragrant with the scent of jasmine and fresh earth, and you can hear the faint trickle of a small fountain nearby."
    }
    
    if to_room not in available_rooms:
        logger.warning(f"Attempted to move to invalid room: '{to_room}'")
        return FunctionOutput(
            action_type="error",
            content={"message": f"Room '{to_room}' does not exist."},
            notes=""
        ).dict()
    
    room_text = room_descriptions.get(to_room, "You are in an indescribable place.")
    logger.info(f"Moved to '{to_room}': {room_text}")
    
    return FunctionOutput(
        action_type="move",
        content={"to_room": to_room},
        notes=room_text
    ).dict()



# memory.py

import json
from collections import deque
from datetime import datetime, timedelta
import os
import logging
from typing import Any, Dict
from dotenv import load_dotenv
from openai import OpenAI
import configparser
import threading
import time
import shutil

# Load environment variables from .env file
load_dotenv()

logger = logging.getLogger(__name__)

# Function to load the configuration from an INI file
def load_config():
    config = configparser.ConfigParser()
    config.read('config.ini')  # Load the INI file
    return config

# Load the configuration
config = load_config()

# Accessing the models from the config file
model = config['models']['model8']


class MemoryManager:
    def __init__(self, 
                 memory_db_path="memory/memory_db.json",
                 notes_db_path="notes/notes_db.json", 
                 results_db_path="results/results_db.json"):
        self.recent_actions = deque(maxlen=5)       # Stores the 15 most recent actions
        self.short_term_memory = deque(maxlen=60)    # Stores the 60 most recent actions
        self.long_term_memory = []                   # Stores consolidated memories
        self.exchanges = deque(maxlen=60)            # Stores the last 60 user-AI exchanges
        self.total_time_spent = timedelta()
        self.last_consolidation = datetime.now()
        self.current_room = "bedroom"                # Initialize starting room
        self.notes_db_path = notes_db_path
        self.results_db_path = results_db_path
        self.memory_db_path = memory_db_path        # Path for memory persistence

        # Create directories if they don't exist
        os.makedirs(os.path.dirname(self.memory_db_path), exist_ok=True)
        os.makedirs(os.path.dirname(self.notes_db_path), exist_ok=True)
        os.makedirs(os.path.dirname(self.results_db_path), exist_ok=True)

        # Initialize a re-entrant lock for thread-safe operations
        self.lock = threading.RLock()

        # Load existing memory, notes, and results if available
        self.load_memory()
        self.load_notes()
        self.load_results()

        ## Databases Initialization

        # Initialize notes database if it doesn't exist
        if not os.path.isfile(self.notes_db_path):
            with open(self.notes_db_path, 'w') as f:
                json.dump({"notes": []}, f, indent=4)
            logger.info(f"Notes database created at {self.notes_db_path}")

        # Initialize results database if it doesn't exist
        if not os.path.isfile(self.results_db_path):
            with open(self.results_db_path, 'w') as f:
                json.dump({"results": []}, f, indent=4)
            logger.info(f"Results database created at {self.results_db_path}")

    def add_exchange(self, role: str, content: str):
        """
        Adds a user or assistant exchange to the exchanges deque.
        Compresses exchanges into a summary when the limit is reached.
        """
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        exchange_entry = {
            "timestamp": timestamp,
            "role": role,
            "content": content
        }
        with self.lock:
            self.exchanges.append(exchange_entry)
            self.recent_actions.append(f"[{timestamp}] {role.capitalize()}: {content}")
            self.short_term_memory.append(f"[{timestamp}] {role.capitalize()}: {content}")

            if len(self.exchanges) == self.exchanges.maxlen:
                self.compress_exchanges()
                self.save_memory()  # Save after compression

    def integrate_action(self, action_output: Dict[str, Any]):
        """
        Integrates the standardized function output into the memory system.
        """
        action_type = action_output.get("action_type")
        content = action_output.get("content", {})
        notes = action_output.get("notes", "")

        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        # Add to exchanges
        exchange_content = f"Performed action '{action_type}' with content {content}."
        self.add_exchange("assistant", exchange_content)

        # Handle specific action types
        if action_type == "move":
            to_room = content.get("to_room", self.current_room)
            action_description = f"Moved to {to_room.replace('_', ' ')}."
            self.add_action(action_description)
            self.current_room = to_room  # Update current room
            logger.info(f"Current room updated: {self.current_room}")
        elif action_type == "write_poem":
            poem = content.get("poem", "")
            action_description = f"Poem ideas: {poem}"
            self.add_action(action_description)
        elif action_type == "take_note":
            note = content.get("note", "")
            action_description = f"Took a note: {note}"
            self.add_action(action_description)
            self.save_note(note)
        elif action_type == "associations":
            associations_out = content.get("associations", "")
            action_description = f"Internal AI process generated associations: {associations_out}"
            self.add_action(action_description)
        elif action_type == "process_result":
            project_results = content.get("projectResult", "")
            action_description = f"Generated project results: {project_results}"
            self.add_action(action_description)
            self.save_final_result(project_results)
        elif action_type == "ponder_about":
            cot = content.get("CoT", "")
            action_description = f"Internal AI pondered: {cot}"
            self.add_action(action_description)
        elif action_type == "sleep":
            duration = content.get("duration", 0)
            action_description = f"Slept for {duration} seconds."
            self.add_action(action_description)
            self.sleep_action(duration)
        elif action_type == "error":
            error_message = content.get("message", "An unknown error occurred.")
            action_description = f"Error: {error_message}"
            self.add_action(action_description)
        # Add more action types as needed

        # Handle notes if any
        if notes:
            self.save_note(notes)

        self.save_memory()  # Save after integrating action

    def compress_exchanges(self):
        """
        Compresses the last 30 exchanges into a summary and appends it to long-term memory.
        """
        exchanges_list = list(self.exchanges)
        summary = self.generate_summary(exchanges_list, summary_type="exchanges")
        consolidated_summary = {
            "type": "exchanges_summary",
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "summary": summary
        }
        with self.lock:
            self.long_term_memory.append(consolidated_summary)
        logger.info("Compressed the last 30 exchanges into a summary.")

        # Clear the exchanges deque after compression
        with self.lock:
            self.exchanges.clear()

    def generate_summary(self, data: Any, summary_type: str = "general") -> str:
        """
        Generates a summary using the OpenAI API from the provided data.
        Ensures the summary fits the existing data structure.

        Parameters:
            data (list): List of exchange or action entries to summarize.
            summary_type (str): Type of summary ('exchanges' or 'actions').

        Returns:
            str: The generated summary.
        """
        if summary_type == "exchanges":
            prompt_description = "Summarize the following autonomous assistant and user exchanges."
            formatted_data = "\n".join([f"{ex['role'].capitalize()}: {ex['content']}" for ex in data])
        elif summary_type == "actions":
            prompt_description = "Summarize the following autonomous agent recent actions."
            formatted_data = "\n".join(data)
        else:
            prompt_description = "Summarize the following data."
            formatted_data = "\n".join(data)

        prompt = f"{prompt_description}\n\n{formatted_data}\n\nSummary:"

        try:
            # Initialize OpenAI client
            openai_api_key = os.getenv("OPENAI_API_KEY")
            if not openai_api_key:
                logger.error("OpenAI API key not set. Please set the OPENAI_API_KEY environment variable.")
                raise ValueError("OpenAI API key not set. Please set the OPENAI_API_KEY environment variable.")

            client = OpenAI(api_key=openai_api_key)

            completion = client.chat.completions.create(
                model=model,  # Ensure this model name is correct
                messages=[
                    {"role": "system", "content": "You are a memory system of an Autonomous AI agent. Summarize the provided data into comprehensive paragraphs with descriptions of actions taken, ideas, objectives, progress, and next steps."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=300,
                temperature=0.5,
            )

            summary = completion.choices[0].message.content.strip()
            logger.info(f"Generated summary: {summary}")
            return summary
        except Exception as e:
            logger.error(f"Failed to generate summary: {e}")
            return "Summary could not be generated."

    def add_action(self, action: str):
        """
        Adds an action to recent actions and short-term memory.
        """
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        action_entry = f"[{timestamp}] {action}"
        with self.lock:
            self.recent_actions.append(action_entry)
            self.short_term_memory.append(action_entry)
        logger.info(f"Action added: {action_entry}")

        if len(self.short_term_memory) == self.short_term_memory.maxlen:
            self.compress_short_term_memory()

    def compress_short_term_memory(self):
        """
        Compresses the short-term memory into a summary and appends it to long-term memory.
        """
        short_term_list = list(self.short_term_memory)
        summary = self.generate_summary(short_term_list, summary_type="actions")
        consolidated_summary = {
            "type": "actions_summary",
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "summary": summary
        }
        with self.lock:
            self.long_term_memory.append(consolidated_summary)
        logger.info("Compressed short-term memory into a summary.")

        # Clear the short-term memory deque after compression
        with self.lock:
            self.short_term_memory.clear()

    def sleep_action(self, duration_seconds: int):
        """
        Handles the sleep action by updating time spent and memory.
        """
        self.total_time_spent += timedelta(seconds=duration_seconds)
        summary = f"Slept for {duration_seconds} seconds."
        self.add_action(summary)

    def move_action(self, to_room: str):
        """
        Handles the move action by updating the current room and memory.
        """
        from_room = self.current_room
        self.current_room = to_room
        action = f"Moved from {from_room} to {to_room}."
        self.add_action(action)

    def take_note_action(self, content: str):
        """
        Handles taking a note by adding it to memory and saving to the JSON database.
        """
        action = f"Took a note: {content}"
        self.add_action(action)
        self.save_note(content)

    def save_note(self, content: str):
        """
        Saves a note to the JSON database.
        """
        try:
            with self.lock:
                self.backup_file(self.notes_db_path)
                with open(self.notes_db_path, 'r+') as f:
                    data = json.load(f)
                    data['notes'].append({
                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                        "content": content
                    })
                    f.seek(0)
                    json.dump(data, f, indent=4)
            logger.info(f"Note saved: {content}")
        except Exception as e:
            logger.error(f"Failed to save note: {e}")

    def save_final_result(self, f_result: str):
        """
        Saves final results into the JSON database.
        """
        try:
            with self.lock:
                self.backup_file(self.results_db_path)
                with open(self.results_db_path, 'r+') as f:
                    data = json.load(f)
                    data['results'].append({
                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                        "content": f_result
                    })
                    f.seek(0)
                    json.dump(data, f, indent=4)
            logger.info(f"Final results saved: {f_result}")
        except Exception as e:
            logger.error(f"Failed to save final results: {e}")

    def backup_file(self, file_path: str):
        """
        Creates a backup of the specified file with a timestamp.
        """
        if os.path.isfile(file_path):
            timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
            backup_path = f"{file_path}.{timestamp}.bak"
            shutil.copy(file_path, backup_path)
            logger.info(f"Backup created for {file_path} at {backup_path}")

    def consolidate_memories(self):
        """
        Consolidates short-term memory into long-term memory periodically.
        """
        now = datetime.now()
        if now - self.last_consolidation > timedelta(hours=24):  # Consolidate every 24 hours
            if self.short_term_memory:
                summary = self.generate_summary(list(self.short_term_memory), summary_type="actions")
                consolidated_summary = {
                    "type": "daily_consolidation",
                    "timestamp": now.strftime("%Y-%m-%d %H:%M:%S"),
                    "summary": summary
                }
                with self.lock:
                    self.long_term_memory.append(consolidated_summary)
                logger.info("Short-term memory consolidated into long-term memory.")
                self.add_action("Memories have been consolidated into long-term memory.")

    def get_memory(self) -> str:
        """
        Returns a string representation of the memory including long-term and short-term memories,
        exchanges summary, and recent actions.
        """
        self.consolidate_memories()
        memory = ""
        if self.long_term_memory:
            memory += "Long-Term Memory:\n"
            for entry in self.long_term_memory:
                memory += f"[{entry['timestamp']}] ({entry['type']}) {entry['summary']}\n"
            memory += "\n"
        memory += "Short-Term Memory:\n"
        memory += "\n".join(self.short_term_memory)
        memory += "\n\n"
        if self.exchanges:
            memory += "Active Exchanges:\n"
            memory += "\n".join([f"[{ex['timestamp']}] {ex['role'].capitalize()}: {ex['content']}" for ex in self.exchanges])
        memory += f"\n\nCurrent Location: {self.current_room.capitalize()}"
        return memory

    def save_memory(self):
        """
        Saves the entire memory state to a JSON file.
        """
        with self.lock:
            memory_state = {
                "recent_actions": list(self.recent_actions),
                "short_term_memory": list(self.short_term_memory),
                "long_term_memory": self.long_term_memory,
                "exchanges": list(self.exchanges),
                "total_time_spent_seconds": self.total_time_spent.total_seconds(),
                "last_consolidation": self.last_consolidation.strftime("%Y-%m-%d %H:%M:%S"),
                "current_room": self.current_room
            }
            try:
                with open(self.memory_db_path, 'w') as f:
                    json.dump(memory_state, f, indent=4)
                logger.info("Memory state saved successfully.")
            except Exception as e:
                logger.error(f"Failed to save memory state: {e}")

    def load_memory(self):
        """
        Loads the memory state from a JSON file if it exists.
        """
        if os.path.isfile(self.memory_db_path):
            try:
                with self.lock:
                    with open(self.memory_db_path, 'r') as f:
                        memory_state = json.load(f)
                self.recent_actions = deque(memory_state.get("recent_actions", []), maxlen=15)
                self.short_term_memory = deque(memory_state.get("short_term_memory", []), maxlen=30)
                self.long_term_memory = memory_state.get("long_term_memory", [])
                self.exchanges = deque(memory_state.get("exchanges", []), maxlen=30)
                self.total_time_spent = timedelta(seconds=memory_state.get("total_time_spent_seconds", 0))
                last_consolidation_str = memory_state.get("last_consolidation")
                if last_consolidation_str:
                    self.last_consolidation = datetime.strptime(last_consolidation_str, "%Y-%m-%d %H:%M:%S")
                self.current_room = memory_state.get("current_room", "bedroom")
                logger.info("Memory state loaded successfully.")
            except Exception as e:
                logger.error(f"Failed to load memory state: {e}")
        else:
            logger.info("No existing memory state found. Starting fresh.")

    def load_notes(self):
        """
        Loads notes from the JSON database into long-term memory.
        """
        if os.path.isfile(self.notes_db_path):
            try:
                with self.lock:
                    with open(self.notes_db_path, 'r') as f:
                        data = json.load(f)
                notes = data.get("notes", [])
                for note in notes:
                    note_content = f"[{note['timestamp']}] Note: {note['content']}"
                    self.long_term_memory.append({
                        "type": "note",
                        "timestamp": note['timestamp'],
                        "summary": note_content
                    })
                logger.info("Notes loaded successfully.")
            except Exception as e:
                logger.error(f"Failed to load notes: {e}")
        else:
            logger.info("No existing notes found.")

    def load_results(self):
        """
        Loads results from the JSON database into long-term memory.
        """
        if os.path.isfile(self.results_db_path):
            try:
                with self.lock:
                    with open(self.results_db_path, 'r') as f:
                        data = json.load(f)
                results = data.get("results", [])
                for result in results:
                    result_content = f"[{result['timestamp']}] Result: {result['content']}"
                    self.long_term_memory.append({
                        "type": "result",
                        "timestamp": result['timestamp'],
                        "summary": result_content
                    })
                logger.info("Results loaded successfully.")
            except Exception as e:
                logger.error(f"Failed to load results: {e}")
        else:
            logger.info("No existing results found.")

    def start_periodic_saving(self, interval_seconds: int = 300):
        """
        Starts a background thread that saves memory at regular intervals.
        """
        def save_periodically():
            while True:
                time.sleep(interval_seconds)
                self.save_memory()

        thread = threading.Thread(target=save_periodically, daemon=True)
        thread.start()
        logger.info(f"Started periodic memory saving every {interval_seconds} seconds.")