Add in a more robust adaptive reasoning and further enhance.

```
import streamlit as st
import g4f
from g4f.client import Client
import os
import json
import time

client = Client()

def make_api_call(messages, max_tokens, is_final_answer=False):
    for attempt in range(3):
        try:
            response = client.chat.completions.create(
                model="gpt-4o",  # Adjust the model as needed
                messages=messages,
                max_tokens=max_tokens,
                temperature=0.2,
                response_format={"type": "json_object"}
            )
            return json.loads(response.choices[0].message.content)
        except Exception as e:
            if attempt == 2:
                if is_final_answer:
                    return {
                        "title": "Error",
                        "content": f"Failed to generate final answer after 3 attempts. Error: {str(e)}"
                    }
                else:
                    return {
                        "title": "Error",
                        "content": f"Failed to generate step after 3 attempts. Error: {str(e)}",
                        "next_action": "final_answer"
                    }
            time.sleep(1)  # Wait for 1 second before retrying

def generate_response(prompt):
    messages = [
        {
            "role": "system",
            "content": """You are an advanced analytical AI assistant with adaptive capabilities to severely analyze complex problems. Your task is to provide detailed, step-by-step explanations of your thought process using advanced analytical methods, adaptive reasoning, and advanced common-sense reasoning. For each step:

1. **Advanced Analysis**: Apply sophisticated analytical techniques to dissect the problem.
2. **Adaptive Reasoning**: Adjust your approach based on the insights gathered at each step.
3. **Common-Sense Reasoning**: Utilize everyday knowledge and logical reasoning to fill in gaps and make sound judgments.
4. **In-depth Exploration**: Explore multiple dimensions and perspectives of the problem.
5. **Critical Evaluation**: Critically evaluate your findings and adjust hypotheses accordingly.

Response Format:
Use JSON with keys:
- 'title': A clear, concise title describing the current reasoning phase.
- 'content': Elaborate on your thought process in this step.
- 'next_action': Decide whether to 'continue' reasoning or provide a 'final_answer'.

Key Instructions:
- Employ at least 5 distinct reasoning steps.
- Use advanced analytical methods (e.g., statistical analysis, logical deductions, scenario planning).
- Apply advanced common-sense reasoning to make logical inferences and fill in gaps in information.
- Adapt your reasoning strategies based on the complexity and nuances of the problem.
- Acknowledge your limitations and explicitly state what you can and cannot do.
- Evaluate alternative answers or approaches thoroughly.
- Critically assess your reasoning; identify potential flaws or biases.
- Ensure that your explanations are consistent and coherent throughout the reasoning process.
- Utilize diverse methods to derive or verify your answer.
- Incorporate relevant domain knowledge and best practices.
- Quantify certainty levels for each step and the final conclusion when applicable.
- Consider potential edge cases, exceptions, or unintended consequences.
- Provide clear justifications for eliminating alternative hypotheses.

Example of a valid JSON response:
```json
{
    "title": "Advanced Statistical Analysis",
    "content": "I will perform a statistical analysis to determine... [detailed explanation]... This will help quantify the relationships between variables.",
    "next_action": "continue"
}```
"""
            },
            {"role": "user", "content": prompt},
            {
                "role": "assistant",
                "content": "Understood. I will proceed to analyze the problem using advanced analytical methods, adaptive reasoning, and common-sense reasoning."
            }
        ]

    steps = []
    step_count = 1
    total_thinking_time = 0

    while True:
        start_time = time.time()
        step_data = make_api_call(messages, 800)
        end_time = time.time()
        thinking_time = end_time - start_time
        total_thinking_time += thinking_time

        steps.append((f"Step {step_count}: {step_data['title']}", step_data['content'], thinking_time))

        messages.append({"role": "assistant", "content": json.dumps(step_data)})

        # Adaptive Reasoning: Modify approach based on previous steps
        # (This could be expanded to adjust parameters or strategy)

        if step_data.get('next_action', '') == 'final_answer':
            break

        step_count += 1

        # Yield after each step for Streamlit to update
        yield steps, None  # Total time is yielded at the end

    # Generate final answer
    messages.append({"role": "user", "content": "Please provide the final answer based on your reasoning above."})

    start_time = time.time()
    final_data = make_api_call(messages, 500, is_final_answer=True)
    end_time = time.time()
    thinking_time = end_time - start_time
    total_thinking_time += thinking_time

    steps.append(("Final Answer", final_data['content'], thinking_time))

    yield steps, total_thinking_time

def main():
    st.set_page_config(page_title="Adaptive AI Reasoning Chains", page_icon="🧠", layout="wide")

    st.title("Adaptive AI Assistant with Advanced Analytical and Common-Sense Capabilities")

    st.markdown("""
This application utilizes an adaptive AI assistant that applies advanced analytical methods and common-sense reasoning to severely analyze complex problems.
        
Forked from [bklieger-groq](https://github.com/bklieger-groq)
        
Open source [repository here](https://github.com/win4r/o1)
""")

    # Text input for user query
    user_query = st.text_input(
        "Enter a complex problem for analysis:",
        placeholder="e.g., Analyze the potential impacts of implementing a universal basic income."
    )

    if user_query:
        st.write("Generating response...")

        # Create empty elements to hold the generated text and total time
        response_container = st.empty()
        time_container = st.empty()

        # Generate and display the response
        for steps, total_thinking_time in generate_response(user_query):
            with response_container.container():
                for i, (title, content, thinking_time) in enumerate(steps):
                    if title.startswith("Final Answer"):
                        st.markdown(f"### {title}")
                        st.markdown(content.replace('\n', '<br>'), unsafe_allow_html=True)
                    else:
                        with st.expander(title, expanded=False):
                            st.markdown(content.replace('\n', '<br>'), unsafe_allow_html=True)

            # Only show total time when it's available at the end
            if total_thinking_time is not None:
                time_container.markdown(f"**Total thinking time: {total_thinking_time:.2f} seconds**")

if __name__ == "__main__":
    main()