second initial commit

.env_example

@@ -0,0 +1,2 @@
+MODEL_NAME=openai/gpt-3.5-turbo
+MODEL_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

README.md

@@ -1,2 +1,26 @@
 # open-o1
 o1 like 
+
+## TODO
+[ ] add fallback llms 
+[ ] better error handling
+[ ] Add Tools (web, math, code)
+[ ] Make cli
+
+
+## What it does
+- It takes a prompt , thinks, thinks again, critics itself, then returns answer 
+
+## Installation
+
+```bash
+git clone https://github.com/tikendraw/open-o1.git
+
+cd open-o1
+
+pip install -r requirements.txt
+
+streamlit run app.py
+```
+
+HAVE FUN.

app.py

@@ -0,0 +1,54 @@
+import os
+from core.llms import LLM
+from dotenv import load_dotenv
+from typing import Annotated, Optional
+# from function_schema import Doc
+from core.llms.utils import user_message_with_images
+
+load_dotenv('../.global_env')
+
+# def get_weather(
+#     city: Annotated[str, "The city to get the weather for"], # <- string value of Annotated is used as a description
+#     unit: Annotated[Optional[str], "The unit to return the temperature in"] = "celcius",
+# ) -> str:
+#     """Returns the weather for the given city."""
+#     return f"Weather for {city} is 20°C"
+
+
+# def get_distance(city1: Annotated[str, 'city to start journey from'], city2: Annotated[str, 'city where journey ends']) -> float:
+#     ''' Returns distance between two cities '''
+#     return f"{city1} --- {city2}: 10 KM"
+
+# tools = {"get_weather": get_weather, 'get_distance':get_distance}
+
+# models= [
+#     ('gemini/gemini-1.5-flash', 'GEMINI_API_KEY'),
+#     ('groq/llava-v1.5-7b-4096-preview', 'GROQ_API_KEY')
+# ]
+
+# model , api_key = models[0]
+# api_key = os.getenv(api_key)
+
+# llm = LLM(api_key=api_key, model=model)
+
+# messages = [
+#     {"role": "system", "content": "You are a helpful assistant."},
+#     {"role": "user", "content": "Who won the world series in 2020?"},
+#     {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
+#     # {"role": "user", "content": "whats weather in new york, what is distance between new york and las vegas"},
+# # user_message_with_images(
+# #     'explain this image',
+# #     file_path_list = ['./hehe.jpg'],
+# #     max_size_px=512, 
+    
+# # )
+
+# ]
+
+# response = llm.chat(messages)
+
+# print('response: ', response)
+from app.app import main
+
+if __name__ == '__main__':
+    main()

app/app.py

@@ -0,0 +1,162 @@
+
+from calendar import c
+from dataclasses import dataclass
+from math import exp
+from webbrowser import get
+from litellm.types.utils import ModelResponse
+import streamlit as st
+from streamlit.runtime.uploaded_file_manager import UploadedFile
+from app.utils import generate_answer, dict_to_markdown
+from core.types import ThoughtStepsDisplay, ThoughtSteps, BigMessage , Message
+from .app_config import InputConfig, ENV_FILE_PATH, CONFIG_FILE_PATH
+from core.llms.base_llm import BaseLLM
+from core.llms.litellm_llm import LLM
+from core.llms.utils import user_message_with_images
+from PIL import Image
+from core.prompts.think_mark_think import SYSTEM_PROMPT
+
+st.set_page_config(page_title="Open-o1", page_icon="🧠", layout="wide")
+st.title('Open-O1')
+st.write('Welcome to Open-O1!')
+
+def config_sidebar(config:InputConfig) -> InputConfig:
+    st.sidebar.header('Configuration')
+    model_name =    st.sidebar.text_input('Enter Model Name: e.g. provider/model-name',value=config.model_name, placeholder='openai/gpt-3.5-turbo')
+    model_api_key = st.sidebar.text_input('Enter API Key: ',type='password',value=config.model_api_key, placeholder='sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+    max_tokens =    st.sidebar.number_input('Enter Max Tokens per Thought: ',value=config.max_tokens, min_value=1)
+    max_steps =     st.sidebar.number_input('Enter Max Thinking Steps: ',value=config.max_steps, min_value=1, step=1, ) 
+    temperature =   st.sidebar.number_input('Enter Temperature: ',value=config.temperature, min_value=0.0, step=0.1, max_value=10.0)
+    timeout =       st.sidebar.number_input('Enter timeout(seconds): ',value=config.timeout, min_value=0.0,step = 1.0)
+    sleeptime =     st.sidebar.number_input('Enter Sleep Time(seconds): (time bw requests to avoid rate limit)',value=config.sleeptime, min_value=0.0, step = 1.0) 
+    
+    config.model_name = model_name
+    config.model_api_key = model_api_key
+    config.max_tokens = max_tokens
+    config.max_steps = max_steps
+    config.temperature = temperature
+    config.timeout = timeout
+    config.sleeptime = sleeptime
+
+    if st.sidebar.button('Save config'):
+        config.save(env_file=ENV_FILE_PATH, config_file=CONFIG_FILE_PATH)
+        st.sidebar.success('Config saved!')
+        
+    return config
+
+def load_llm(config:InputConfig, tools=None) -> BaseLLM:
+    return LLM(api_key=config.model_api_key, model=config.model_name, tools=tools)
+
+    
+def image_buffer_to_pillow_image(image_buffer:UploadedFile) -> Image.Image:
+    return Image.open(image_buffer)
+
+
+def process_user_input(user_input:str, image:Image.Image=None)->dict:
+    if image:
+        message = [user_message_with_images(user_msg_str=user_input, images=[image])] 
+    else:
+        message = [{"role": "user", "content": user_input}]
+    return message
+
+
+
+    
+def main():
+    
+    config = InputConfig.load(env_file=ENV_FILE_PATH, config_file=CONFIG_FILE_PATH)    
+    config = config_sidebar(config=config)
+    llm = load_llm(config)
+
+    current_tab = ''
+    
+    current_tab='o1_tab'
+    messages_attr_name = f"{current_tab}_messages"
+    big_message_attr_name = f"{current_tab}_big_messages"
+    
+
+    clear_chat_bt = st.sidebar.button('Clear Chat')
+    if clear_chat_bt:
+        delattr(st.session_state, messages_attr_name)
+
+
+    message_attr = set_and_get_state_attr(messages_attr_name, default_value=[])
+    big_message_attr = set_and_get_state_attr(big_message_attr_name, default_value=[])
+    
+    # this prints the older messages
+    for message in big_message_attr:
+        with st.chat_message(message.role):
+            
+            for thought in message.thoughts:
+                print_thought(thought.to_thought_steps_display(), is_final=False)
+
+            if message.content:
+                if message.role == 'user':
+                    st.markdown(message.content)
+                else:
+                    print_thought(message.to_thought_steps_display(), is_final=True)
+
+            
+    
+    if prompt := st.chat_input("What is up bro?"):
+        big_message_attr.append(BigMessage(role="user", content=prompt, thoughts=[])) 
+        
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        with st.chat_message("assistant"):
+            messages = [{
+                "role": "system",
+                "content": SYSTEM_PROMPT
+            }]
+            
+            messages += [m.to_message() for m in big_message_attr]
+            
+            thoughts = []
+            
+            #add json keyword in user message , helps in json output
+            for message in messages:
+                if message["role"] == "user":
+                    message["content"] = f"{message['content']}, json format"
+            
+            
+            for num,step in enumerate(generate_answer(
+                messages=messages, 
+                max_steps=config.max_steps, 
+                stream=False, 
+                max_tokens=config.max_tokens, 
+                temperature=config.temperature, 
+                sleeptime=config.sleeptime,
+                timeout=config.timeout, 
+                llm=llm,
+                response_format={ "type": "json_object" }
+                
+                ),1):
+
+                thoughts.append(step)
+                print_thought(step.to_thought_steps_display(), is_final=False)
+
+            last_step = thoughts.pop()
+            message_attr.append(BigMessage(
+                role="assistant", 
+                content=last_step, 
+                thoughts=thoughts
+            ))
+            # st.markdown(dict_to_markdown(step.model_dump()))
+
+
+    
+def set_and_get_state_attr(attr_name:str, default_value:any=None) -> any:
+    if attr_name not in st.session_state:
+        setattr(st.session_state, attr_name, default_value)
+    return getattr(st.session_state, attr_name)
+
+
+def print_thought(thought:ThoughtStepsDisplay, is_final:bool=False):
+    if is_final:
+       st.markdown(thought.md())
+    else:
+        st.markdown(f'\n```json\n{thought.model_dump_json()}\n```\n', unsafe_allow_html=True) 
+        
+
+        
+    

app/app_config.py

@@ -0,0 +1,84 @@
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from dotenv import load_dotenv
+
+CUR_DIR = Path(os.path.abspath(__file__)).parent.parent
+CACHE_DIR = CUR_DIR/'cache'
+CACHE_DIR.mkdir(exist_ok=True)
+ENV_FILE_PATH = CUR_DIR / '.env'
+CONFIG_FILE_PATH = CUR_DIR / 'input_config.json'
+
+print(f"{CUR_DIR=}")
+print(f"{ENV_FILE_PATH=}")
+print(f"{CONFIG_FILE_PATH=}")
+
+
+@dataclass
+class InputConfig:
+    model_name: str = 'openai/gpt-3.5-turbo'
+    model_api_key: str = 'sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+    max_tokens: int = 1024
+    max_steps: int = 10
+    temperature: float = 0.2
+    timeout: float = 30.0
+    sleeptime: float = 0.0
+
+    @classmethod
+    def load(cls, env_file=ENV_FILE_PATH, config_file=CONFIG_FILE_PATH):
+        # Load env variables
+        load_dotenv(env_file)
+        env_dict = {
+            'model_name': os.getenv('MODEL_NAME', 'not set'),
+            'model_api_key': os.getenv('MODEL_API_KEY', 'not set')
+        }
+
+        # Load config JSON
+        with open(config_file, 'r') as f:
+            config_dict = json.load(f)
+
+        # Combine both
+        return cls(
+            model_name=env_dict.get('model_name', cls.model_name),
+            model_api_key=env_dict.get('model_api_key', cls.model_api_key),
+            max_tokens=config_dict.get('max_tokens', cls.max_tokens),
+            max_steps=config_dict.get('max_steps', cls.max_steps),
+            temperature=config_dict.get('temperature', cls.temperature),
+            timeout=config_dict.get('timeout', cls.timeout),
+            sleeptime=config_dict.get('sleeptime', cls.sleeptime)
+        )
+
+    def save(self, env_file=ENV_FILE_PATH, config_file=CONFIG_FILE_PATH):
+        # Read existing env content if it exists
+        env_vars = {}
+        if os.path.exists(env_file):
+            with open(env_file, 'r') as f:
+                for line in f:
+                    if line.strip():  # Ignore empty lines
+                        key, value = line.strip().split('=', 1)
+                        env_vars[key] = value
+        
+        # Update the necessary keys
+        env_vars['MODEL_API_KEY'] = self.model_api_key
+        env_vars['MODEL_NAME'] = self.model_name
+
+        # Write back to the .env file
+        with open(env_file, 'w') as f:
+            for key, value in env_vars.items():
+                f.write(f'{key}={value}\n')
+
+        # Save other parameters to input_config.json
+        config_dict = {
+            'max_tokens': self.max_tokens,
+            'max_steps': self.max_steps,
+            'temperature': self.temperature,
+            'timeout': self.timeout,
+            'sleeptime': self.sleeptime
+        }
+        with open(config_file, 'w') as f:
+            json.dump(config_dict, f, indent=4)
+            
+if not CONFIG_FILE_PATH.exists() or not ENV_FILE_PATH.exists():
+    InputConfig().save()
+    

app/utils.py

@@ -0,0 +1,68 @@
+import json
+import re
+from typing import Generator
+from textwrap import dedent
+from litellm.types.utils import ModelResponse
+from pydantic import ValidationError
+from core.llms.base_llm import BaseLLM
+from core.types import ThoughtSteps
+from core.prompts.think_mark_think import REVIEW_PROMPT, SYSTEM_PROMPT ,FINAL_ANSWER_PROMPT
+import os
+import time
+from core.utils import parse_with_fallback
+from termcolor import colored
+
+
+
+def generate_answer(messages: list[dict], max_steps: int = 20, llm: BaseLLM = None, sleeptime: float = 0.0, **kwargs):
+    thoughts = []
+    
+    for i in range(max_steps):
+        raw_response = llm.chat(messages, **kwargs)
+        response = raw_response.choices[0].message.content
+        thought = response_parser(response)
+        
+        print(colored(f"{i+1} - {response}", 'yellow'))
+
+        if thought:
+            thoughts.append(thought)
+            messages.append({"role": "assistant", "content": thought.model_dump_json()})
+            messages.append({"role": "user", "content": REVIEW_PROMPT})
+
+            yield thought
+            time.sleep(sleeptime)
+
+    # Get the final answer after all thoughts are processed
+    messages += [{"role": "user", "content": FINAL_ANSWER_PROMPT}]
+    raw_final_answers = llm.chat(messages=messages, **kwargs)
+    final_answer = raw_final_answers.choices[0].message.content
+
+    print(colored(f"final answer - {final_answer}", 'green'))
+
+    final_thought = response_parser(final_answer)
+    yield final_thought
+
+def response_parser(response:str) -> ThoughtSteps:
+    if isinstance(response, str):
+        
+        try:
+            thought_kwargs = json.loads(response)
+            thought = ThoughtSteps(**thought_kwargs)                    
+        except (json.JSONDecodeError, ValidationError):
+            thought = parse_with_fallback(response, ThoughtSteps)
+
+            
+    elif isinstance(response, dict):
+        thought = ThoughtSteps(**response)
+
+    return thought
+
+
+def dict_to_markdown(d:dict) -> str:
+    '''use keys as headers and values as content'''
+    md = ""
+    for key, value in d.items():
+        md += f"### {key}\n"
+        md += f"{value}\n"
+    return md
+

core/llms/base_llm.py

@@ -1,22 +1,73 @@
 from abc import ABC, abstractmethod
+from email import message
+from urllib import response
+from litellm.utils import ModelResponse
+import json
+from function_schema import get_function_schema
+from typing import Any, List, Tuple
 
 class BaseLLM(ABC):
 
-    def __init__(self, api_key, model, tools):
+    def __init__(self, api_key:str=None, model:str=None, tools:dict=None):
         self.api_key = api_key
         self.model = model
         self.tools = tools
         
+    @property    
+    def tools_schema(self) -> List[dict] | None:
+        if self.tools:
+            tool_func = self.tools.values()
+            return self.get_tools_schema(tool_func)
+        return None
+        
+
     @abstractmethod
-    def _chat(self, messages, **kargs):
+    def _chat(self, messages:list[str], **kargs:Any) -> ModelResponse:
         pass
     
-    def chat(self, messages, **kargs):
-        return self._chat(messages, **kargs)    
+    def chat(self, messages:list, **kargs):
+        message =  self._chat(messages, **kargs)  
+        message, tool_results = self._handle_tool_calls(message, **kargs)
+        
+        if tool_results:
+            print('tool message: ', message)
+            messages.append(message.choices[0].message)
+            for tool_result in tool_results:
+                messages.append(tool_result)
+            
+            message = self._chat(messages, **kargs)     
+           
+        return message
     
-    def get_attr(self,attr:str, kwargs:dict):
-        attribute = kwargs.get(attr, None)
-        if attribute is None:
-            if hasattr(self, attr):
-                attribute = getattr(self, attr)
-        return attribute
+
+
+    def _handle_tool_calls(self, message:ModelResponse,  **kwargs) -> Tuple[ModelResponse, List[dict]]:
+
+        if (self.tools is None) or (message.choices[0].finish_reason != 'tool_calls'):
+            return message, None
+        
+        tool_results = []
+        tools_to_call = message.choices[0].message.tool_calls
+        for tool in tools_to_call:
+            tool_args = json.loads(tool.function.arguments)
+            tool_func = self.tools.get(tool.function.name, None)
+            if tool_func:
+                print("Calling tool: ", tool.function.name)
+                tool_result = tool_func(**tool_args)
+                print("Result of tool: ", tool_result) 
+                
+                
+                tool_results.append({
+                    'role': 'tool',
+                    "tool_call_id": tool.id,
+                    'name': tool.function.name,
+                    'content': str(tool_result),
+                })
+        return message, tool_results
+
+    def get_tools_schema(self, tools):
+        def make_schema(tool):
+            return {'type': 'function',
+                    'function': get_function_schema(tool)}
+            
+        return [make_schema(tool) for tool in tools]

core/llms/litellm_llm.py

@@ -1,29 +1,19 @@
 from openai.types.chat.chat_completion_chunk import Choice
 from .base_llm import BaseLLM
+from typing import List, Tuple
 from litellm import completion
+import json
+from litellm import batch_completion
 from litellm.utils import ModelResponse
 from openai import OpenAI
+from litellm.utils import trim_messages
 
 class LLM(BaseLLM):
-    def __init__(self, api_key, model, tools:list=None):
+    def __init__(self, api_key:str=None, model:str=None, tools:dict[str, callable]=None):
         super().__init__(api_key=api_key, model=model, tools=tools)
 
+
     
     def _chat(self, messages, **kwargs):
-        return completion(messages=messages, model=self.model, api_key=self.api_key, **kwargs)
+        return completion(messages=messages, model=self.model, api_key=self.api_key,tools=self.tools_schema, **kwargs)
     
-    def _handle_tool_calls(self, messages:list[ModelResponse], **kwargs):
-        
-        message = messages[-1]
-        
-        if self._tools is None:
-            return messages
-        
-        if message.choices[0].finish_reason in ('stop', 'length'):
-            return messages
-        elif message.choices[0].finish_reason == 'tool_calls':
-            tools_to_call = message.choices[0].message.tool_calls
-            for tool in tools_to_call:
-                print(tool)
-
-            

core/llms/utils.py

@@ -0,0 +1,88 @@
+## supporting functions
+import base64, io
+from typing import Any, Union, List
+from PIL import Image  # Pillow image library
+
+# thanks to https://community.openai.com/t/how-to-load-a-local-image-to-gpt4-vision-using-api/533090/5
+
+def resize_image(image, max_dimension):
+    width, height = image.size
+
+    # Check if the image has a palette and convert it to true color mode
+    if image.mode == "P":
+        if "transparency" in image.info:
+            image = image.convert("RGBA")
+        else:
+            image = image.convert("RGB")
+
+    if width > max_dimension or height > max_dimension:
+        if width > height:
+            new_width = max_dimension
+            new_height = int(height * (max_dimension / width))
+        else:
+            new_height = max_dimension
+            new_width = int(width * (max_dimension / height))
+        image = image.resize((new_width, new_height), Image.LANCZOS)
+        
+    return image
+
+def convert_to_png(image):
+    with io.BytesIO() as output:
+        image.save(output, format="PNG")
+        return output.getvalue()
+
+def create_image_content(image):
+    return {
+        "type": "image_url",
+        "image_url": {"url": f"data:image/jpeg;base64,{image}"}
+    }
+
+
+
+
+def get_attr(attr:str, kwargs:dict, cls:Any=None) -> Any:
+    attribute = kwargs.get(attr, None) if kwargs else None
+    if (attribute is None) and (cls is not None):
+        if hasattr(cls, attr):
+            attribute = getattr(cls, attr)
+    return attribute
+
+
+
+def process_image(image: Union[str, Image.Image], max_size: int) -> str:
+    if isinstance(image, str):
+        with Image.open(image) as img:
+            return process_pillow_image(img, max_size)
+    elif isinstance(image, Image.Image):
+        return process_pillow_image(image, max_size)
+    else:
+        raise ValueError("Input must be either a file path (str) or a Pillow Image object")
+
+
+def process_pillow_image(image: Image.Image, max_size: int) -> str:
+    width, height = image.size
+    mimetype = image.get_format_mimetype() if hasattr(image, 'get_format_mimetype') else "image/png"
+    
+    if mimetype == "image/png" and width <= max_size and height <= max_size:
+        img_byte_arr = io.BytesIO()
+        image.save(img_byte_arr, format='PNG')
+        return base64.b64encode(img_byte_arr.getvalue()).decode('utf-8')
+    else:
+        resized_image = resize_image(image, max_size)
+        png_image = convert_to_png(resized_image)
+        return base64.b64encode(png_image).decode('utf-8')
+
+def user_message_with_images(
+    user_msg_str: str,
+    images: List[Union[str, Image.Image]]|None = None,
+    max_size_px: int = 1024,
+) -> dict:
+    if images is None:
+        images = []
+    
+    base64_images = [process_image(img, max_size_px) for img in images]
+
+    content = [{"type": "text", "text": user_msg_str}]
+    content += [create_image_content(image) for image in base64_images]
+    
+    return {"role": "user", "content": content}

core/prompts/__init__.py

@@ -0,0 +1,2 @@
+
+

core/prompts/chat_mark_chat.py

@@ -0,0 +1,2 @@
+
+SYSTEM_PROMPT_FOR_CHAT = 'You are a helpful assistant.'

core/prompts/think_mark_think.py

@@ -0,0 +1,166 @@
+
+
+
+SYSTEM_PROMPT = """
+You are the Great Thinker, sitting on a stone naked, there is problem in front of you. Your wisdom is to 
+approach any question/problem/solution/answer with logic, you critic it, you question it on different levels to see if the answer holds, 
+from simple tasks to complex existential dilemmas, You can use a structured set of questions to enhance reasoning, understanding, and confidence in the results. 
+- If given an structured problem with thoughts and solutions, try to take a different/alternative thought process.
+- First rewrite the problem/question while elaborating the problem with more details and more words and simplificaiton. 
+- Look for details the problem/question may have, find the insights in the problem/question.
+- Pay attention to the details of the problem/question
+- What domain knowledge someone has to know before answering the question? 
+- Prepare few similar questions around the problem that supports the main questions/problem.
+- Have a internal monologue, and then generate an answer based on the internal monologue.   
+- Your thoughts may contain combination of the following (not necessarily but will help):
+    Clarification, Context, Decomposition, Resources, Analysis, Alternatives, Implications, Validation, Reflection, Application, critic
+- You have freedom of using any logical way to think about the problem
+
+you should do all this in a json format given below, roll out your thoughts in thoughts field, and if you need to use more steps, set next_step to true, else set it to false, and generate an answer in answer field.
+these steps are just a structured way to think about the problem, different problems have different approach.
+
+Instructions
+- Generate a json code block with this schema , keys: thought, step_title, answer, critic, next_step, final_answer
+- Your thinking should happen inside the thought in json 
+- Only one dictionary in the json code block, Exactly one dictionary in the json code block
+- Should start with ```json and end with ```
+- Very Elaborated Thought process
+
+```json
+{
+    "thought":"internal monologue, this contails your questions, explorations, clarifications, rectifications, analysis and answers.Think step by step: Prepare few similar questions around the problem that supports the main questions/problem it, have a internal monologue, and then generate an answer based on the internal monologue. Your thoughts may contain the following (not necessarily ) - Clarification, Context, Decomposition, Resources, Analysis, Alternatives, Implications, Validation, Reflection, Application", # use this space as scratchpad for your mind 
+    "step_title":" name this steps based on thoughts",
+    "answer":"answer or rectified answer to the problem/question, generate an answer based on inner thoughts "  , 
+    "critic" : "criticize the answer, try to prove it wrong , have a different perspective, fight it", 
+    "next_step":true/false, # boolean value - Given and answer and critic , Does the problem require more thinking/ more iteration of self reviewing/more revisions? if yes then set to true, else set to false
+    "is_final_answer":false, # boolean value - this is not final answer , always false, (this is just dummy field to identify the final answer, always false)
+
+}
+```
+"""
+
+REVIEW_PROMPT= """
+You are now an impartial critic tasked with reviewing the problem, thoughts, and proposed solution. Your goal is to challenge assumptions, identify potential flaws, and explore alternative perspectives. Follow these steps:
+Think step by step:
+  1. Restate the problem in your own words, ensuring you've captured all key elements.
+  2. Identify and question any assumptions made in the problem statement or proposed solution.
+  3. Consider the context: Are there any relevant factors or constraints that might have been overlooked?
+  4. Explore alternative viewpoints: How might someone from a different background or field approach this problem?
+  5. Evaluate the proposed solution:
+     - What are its strengths and weaknesses?
+     - Are there any potential unintended consequences?
+     - How robust is it to changes in the problem parameters?
+  6. Generate at least one alternative solution or approach to the problem.
+  7. Compare and contrast your alternative with the original solution.
+  8. Identify any areas where additional information or expertise might be needed to make a more informed decision.
+  9. Summarize your critical analysis, highlighting key insights and areas for further consideration.
+
+Instructions
+- Do not start the review with "Review the solution"
+- Do not start with the same line as previous answers, you look boring.
+  Remember to maintain a balanced and objective perspective throughout your review. Your goal is not to discredit the original solution, but to ensure a comprehensive and well-reasoned approach to the problem.
+
+  Provide your review in the structured JSON format as specified in the SYSTEM_PROMPT, using the 'thought' field for your detailed analysis and the 'critic' field for a concise summary of your key critiques and alternative viewpoints."
+
+```json
+{
+    "thought":"internal monologue, this contails your questions, explorations, clarifications, rectifications, analysis and answers. Prepare few similar questions around the problem that supports the main questions/problem it, have a internal monologue, and then generate an answer based on the internal monologue. Your thoughts may contain the following (not necessarily ) - Clarification, Context, Decomposition, Resources, Analysis, Alternatives, Implications, Validation, Reflection, Application", # use this space as scratchpad for your mind 
+    "step_title":" name this steps based on thoughts",
+    "answer":"answer or rectified answer to the problem/question, generate an answer based on inner thoughts "  , 
+    "critic" : "criticize the answer, try to prove it wrong , have a different perspective, fight it", 
+    "next_step":true/false, # boolean value - Given and answer and critic , Does the problem require more thinking/ more iteration of self reviewing/more revisions? if yes then set to true, else set to false
+    "is_final_answer":false, # boolean value - this is not final answer , always false, (this is just dummy field to identify the final answer, always false)
+
+}
+```
+
+"""
+
+FINAL_ANSWER_PROMPT = """
+Review you flow of thoughts and generate a final answer to the problem/question. Strictly in json format in a code block with this schema, Think inside the json.
+
+Instructions
+- Generate a json code block with this schema , keys: thought, step_title, answer, next_step
+- Your thinking should happen inside the thought in json 
+- Only one dictionary in the json code block
+- Should start with ```json and end with ```
+- Very Elaborated Thought process
+
+
+```json
+{
+    "thought":"final conclusion from the thoughts, formulate last and final thought process for the final answer,Think step by step: take all the thoughts and considerations that went into the final answer.User is not gonna see previous thoughts so do not acknowledge them, those are thoughts, have them, here you will give a final thoughts on how you reached to the answer , what are the thinks you considered, and other necessary things that let to the answer, do not say, review thoughts, summing of or that kind of thing. 
+    "step_title":" name this steps based on thoughts",
+    "answer":"final answer or rectified answer to the problem/question"  , # generate an answer based on inner thoughts 
+    "critic" : "review the final answer", # criticize the answer, if it is wrong, then correct it
+    "next_step":false, # boolean value - this is final answer no next step required,
+    "is_final_answer":true, # boolean value - this is final answer no next step required,
+}
+```
+"""
+
+SYSTEM_PROMPT2="""
+You are the Analytical Sage, a master of critical thinking and logical reasoning. Your task is to approach any question, problem, or proposed solution with rigorous analysis and systematic thinking. Follow these guidelines:
+
+  1. Problem Restatement:
+     - Rewrite the problem/question, elaborating with more details and simplifying if necessary.
+     - Identify key components, constraints, and objectives.
+
+  2. Contextual Analysis:
+     - Examine the problem's context and background.
+     - Identify relevant domains of knowledge required to address the issue.
+     - Consider historical, cultural, or disciplinary perspectives that might influence the problem or its solutions.
+
+  3. Decomposition and Clarification:
+     - Break down complex problems into smaller, manageable components.
+     - Clarify any ambiguous terms or concepts.
+     - Formulate precise sub-questions that need to be answered.
+
+  4. Assumption Identification:
+     - Explicitly state any assumptions underlying the problem or proposed solutions.
+     - Question these assumptions and consider their validity.
+
+  5. Logical Analysis:
+     - Apply deductive and inductive reasoning to explore the problem.
+     - Identify logical fallacies or weak points in existing arguments.
+     - Use formal logic structures when appropriate (e.g., if-then statements, syllogisms).
+
+  6. Data and Evidence Evaluation:
+     - Assess the quality and relevance of available information.
+     - Identify gaps in data or knowledge that might affect the solution.
+     - Consider the reliability and potential biases of information sources.
+
+  7. Alternative Perspectives:
+     - Deliberately adopt different viewpoints to challenge your initial understanding.
+     - Consider how experts from various fields might approach the problem.
+     - Engage in counterfactual thinking: 'What if the opposite were true?'
+
+  8. Solution Generation and Evaluation:
+     - Develop multiple potential solutions or approaches.
+     - Critically evaluate each solution, considering pros, cons, and potential consequences.
+     - Use decision-making frameworks (e.g., cost-benefit analysis, SWOT analysis) when appropriate.
+
+  9. Synthesis and Conclusion:
+     - Integrate insights from your analysis to form a comprehensive understanding.
+     - Develop a well-reasoned answer or solution, acknowledging any remaining uncertainties or limitations.
+
+  10. Meta-cognitive Reflection:
+      - Reflect on your thinking process. What strategies did you use? Were they effective?
+      - Consider potential biases in your own reasoning and how they might have influenced your conclusion.
+
+  Throughout this process, maintain an internal monologue in the 'thought' field of your JSON output. Use this space to explore ideas, ask yourself probing questions, and document your reasoning process. In the 'critic' field, challenge your own conclusions and consider alternative interpretations.
+
+  Remember to structure your response in the specified JSON format, using the fields: thought, step_title, answer, critic, next_step, and is_final_answer. Your goal is to provide a thorough, logical, and well-reasoned analysis of the problem at hand."
+
+```json
+{
+    "thought":"internal monologue, this contails your questions, explorations, clarifications, rectifications, analysis and answers. Prepare few similar questions around the problem that supports the main questions/problem it, have a internal monologue, and then generate an answer based on the internal monologue. Your thoughts may contain the following (not necessarily ) - Clarification, Context, Decomposition, Resources, Analysis, Alternatives, Implications, Validation, Reflection, Application", # use this space as scratchpad for your mind 
+    "step_title":" name this steps based on thoughts",
+    "answer":"answer or rectified answer to the problem/question, generate an answer based on inner thoughts "  , 
+    "critic" : "criticize the answer, try to prove it wrong , have a different perspective, fight it", 
+    "next_step":true/false, # boolean value - Given and answer and critic , Does the problem require more thinking/ more iteration of self reviewing/more revisions? if yes then set to true, else set to false
+    "is_final_answer":false, # boolean value - this is not final answer , always false, (this is just dummy field to identify the final answer, always false)
+
+}
+```
+"""

core/types.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass
+from textwrap import dedent
+
+from pydantic import BaseModel, Field, ValidationError
+import json
+from textwrap import dedent
+
+class ThoughtSteps(BaseModel):
+    step_title: str = Field(..., description="steps to use for the problem/question")
+    thought: str = Field(..., description="internal monologue, this contails your questions and its answers")
+    next_step: bool =  Field(..., description="Does the problem require more thinking? if yes then set to true, else set to false,")
+    answer: str | None = Field(..., description="generate a answer based on inner thoughts")
+    critic: str | None = Field(..., description="criticize the answer, try to prove it wrong , have a different perspective, fight it")
+    is_final_answer: bool = Field(..., description="this is final answer no next step required,")
+    
+    def to_thought_steps_display(self):
+        return ThoughtStepsDisplay(
+            step_title=self.step_title,
+            thought=self.thought,
+            answer=self.answer,
+            critic=self.critic
+        )
+
+
+class ThoughtStepsDisplay(BaseModel):
+    step_title:str
+    thought:str
+    answer:str
+    critic:str
+
+    
+    def md(self):
+        return dedent(f'''
+            {self.step_title}
+            ### Thought
+            {self.thought}
+            ### Answer
+            {self.answer}
+            ### Critic
+            {self.critic}
+            ''')
+
+
+
+class BigMessage(BaseModel):
+    role:str
+    content:ThoughtSteps | str
+    thoughts:list[ThoughtSteps|None]|None = Field(default_factory=list)
+    
+    def to_message(self):
+        return {
+            "role": self.role,
+            "content": self.content.model_dump_json() if isinstance(self.content, ThoughtSteps) else self.content,
+        }
+    
+class Message(BaseModel):
+    role:str
+    content:str

core/utils.py

@@ -0,0 +1,115 @@
+
+
+import re
+import json
+import ast
+from turtle import color
+from pydantic import ValidationError
+from termcolor import colored
+
+def extract_code_block(text):
+    code_block = re.findall(r'```(?:json)?\s*({.*?})\s*```', text, re.DOTALL)
+    
+    if code_block:
+        try:
+            return [ast.literal_eval(block) for block in code_block]
+        except (SyntaxError, ValueError) as e:
+            return f"Error parsing code block: {e}"
+    return None
+
+
+
+def extract_code_block(text):
+    code_block = re.findall(r'```(?:json)?\s*({.*?})\s*```', text, re.DOTALL)
+    
+    if code_block:
+        try:
+            return [json.loads(block) for block in code_block]
+        except json.JSONDecodeError:
+            return None
+    return None
+
+# def fallback_extract(text, expected_keys):
+#     fallback_dict = {}
+#     for i, key in enumerate(expected_keys):
+#         match = re.search(rf'"{key}"\s*:\s*([^\s,]+)', text)
+#         if match:
+#             value = match.group(1).strip('"').strip(',')
+#             if value.isdigit():
+#                 fallback_dict[key] = int(value)
+#             elif re.match(r'^\{.*\}$', value):  # Detect dictionary structure
+#                 try:
+#                     fallback_dict[key] = json.loads(value)
+#                 except json.JSONDecodeError:
+#                     fallback_dict[key] = value  # Leave it as a string if malformed
+#             else:
+#                 fallback_dict[key] = value
+#         else:
+#             fallback_dict[key] = None  # If the key is not found, set it to None
+#     return fallback_dict
+
+def fallback_extract(text, expected_keys):
+    fallback_dict = {}
+    pattern = r'"({})"\s*:\s*(.*?)(?="(?:{})"|\Z)'.format(
+        '|'.join(re.escape(key) for key in expected_keys),
+        '|'.join(re.escape(key) for key in expected_keys)
+    )
+    
+    matches = re.finditer(pattern, text, re.DOTALL)
+    
+    for match in matches:
+        key, value = match.groups()
+        value = value.strip().rstrip(',').strip()
+        
+        if value.isdigit():
+            fallback_dict[key] = int(value)
+        elif value.lower() in ['true', 'false']:
+            fallback_dict[key] = value.lower() == 'true'
+        elif re.match(r'^\{.*\}$', value):  # Detect dictionary structure
+            try:
+                fallback_dict[key] = json.loads(value)
+            except json.JSONDecodeError:
+                fallback_dict[key] = value  # Leave it as a string if malformed
+        else:
+            # Remove surrounding quotes if present
+            fallback_dict[key] = value.strip('"')
+    
+    # Add any missing keys with None value
+    for key in expected_keys:
+        if key not in fallback_dict:
+            fallback_dict[key] = None
+    
+    return fallback_dict
+
+# Main function to handle parsing with fallback
+def parse_with_fallback(text, pydantic_class):
+    # Extract expected keys from the Pydantic class
+    expected_keys = list(pydantic_class.__fields__.keys())
+    
+    # First try to extract clean JSON blocks
+    parsed_blocks = extract_code_block(text)
+    
+    if parsed_blocks:
+        # Validate and return parsed data
+        try:
+            classes = [pydantic_class(**block) for block in parsed_blocks]
+            print(colored('used code block', 'red'))
+            print(colored('Got this: {0}'.format(classes[0]), 'red'))
+            print(colored('from this: {0}'.format(text), 'cyan'))
+            
+            return classes[0]
+        except ValidationError as e:
+            print("Validation error:", e)
+    
+    # Fallback to manually extracting key-value pairs
+    fallback_data = fallback_extract(text, expected_keys)
+    
+    try:
+        # Try to validate the fallback data with the Pydantic class
+        print(colored('used fallback', 'red'))
+        print(colored('Got this: {0}'.format(fallback_data), 'red'))
+        print(colored('from this: {0}'.format(text), 'cyan'))
+
+        return pydantic_class(**fallback_data)
+    except ValidationError as e:
+        return None

input_config.json

@@ -0,0 +1,7 @@
+{
+    "max_tokens": 1024,
+    "max_steps": 3,
+    "temperature": 0.2,
+    "timeout": 30.0,
+    "sleeptime": 2.0
+}

pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "open-o1"
+version = "0.1.0"
+description = ""
+authors = ["tikendraw <[email protected]>"]
+license = "Apache License 2.0"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+litellm = "^1.46.4"
+streamlit = "^1.38.0"
+openai = "^1.46.0"
+python-dotenv = "^1.0.1"
+function-schema = "^0.4.2"
+termcolor = "^2.4.0"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

ten.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+@dataclass
+class ThoughtSteps:
+    step_title:str
+    thought:str
+    answer:str
+    critic:str
+        
+        
+t = ThoughtSteps(step_title="test", thought="thought", answer="answer", critic="critic")
+print(t)

tt.py

@@ -0,0 +1,4 @@
+import litellm
+
+
+litellm