chat-console 0.3.995__tar.gz → 0.4.0__tar.gz

{chat_console-0.3.995/chat_console.egg-info → chat_console-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.3.995
+Version: 0.4.0
 Summary: A command-line interface for chatting with LLMs, storing chats and (future) rag interactions
 Home-page: https://github.com/wazacraftrfid/chat-console
 Author: Johnathan Greenaway
@@ -28,7 +28,8 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# Chat CLI
+
+c# Chat CLI
 
 A comprehensive command-line interface for chatting with various AI language models. This application allows you to interact with different LLM providers through an intuitive terminal-based interface.
 
@@ -37,6 +38,7 @@ A comprehensive command-line interface for chatting with various AI language mod
 - Interactive terminal UI with Textual library
 - Support for multiple AI models:
   - OpenAI models (GPT-3.5, GPT-4)
+  - OpenAI reasoning models (o1, o1-mini, o3, o3-mini, o4-mini)
   - Anthropic models (Claude 3 Opus, Sonnet, Haiku)
 - Conversation history with search functionality
 - Customizable response styles (concise, detailed, technical, friendly)
@@ -71,6 +73,26 @@ Run the application:
 chat-cli
 ```
 
+### Testing Reasoning Models
+
+To test the OpenAI reasoning models implementation, you can use the included test script:
+```
+./test_reasoning.py
+```
+
+This script will test both completion and streaming with the available reasoning models.
+
+### About OpenAI Reasoning Models
+
+OpenAI's reasoning models (o1, o3, o4-mini, etc.) are LLMs trained with reinforcement learning to perform reasoning. These models:
+
+- Think before they answer, producing a long internal chain of thought
+- Excel in complex problem solving, coding, scientific reasoning, and multi-step planning
+- Use "reasoning tokens" to work through problems step by step before providing a response
+- Support different reasoning effort levels (low, medium, high)
+
+The implementation in this CLI supports both standard completions and streaming with these models.
+
 ### Keyboard Shortcuts
 
 - `q` - Quit the application

{chat_console-0.3.995 → chat_console-0.4.0}/README.md

@@ -1,4 +1,5 @@
-# Chat CLI
+
+c# Chat CLI
 
 A comprehensive command-line interface for chatting with various AI language models. This application allows you to interact with different LLM providers through an intuitive terminal-based interface.
 
@@ -7,6 +8,7 @@ A comprehensive command-line interface for chatting with various AI language mod
 - Interactive terminal UI with Textual library
 - Support for multiple AI models:
   - OpenAI models (GPT-3.5, GPT-4)
+  - OpenAI reasoning models (o1, o1-mini, o3, o3-mini, o4-mini)
   - Anthropic models (Claude 3 Opus, Sonnet, Haiku)
 - Conversation history with search functionality
 - Customizable response styles (concise, detailed, technical, friendly)
@@ -41,6 +43,26 @@ Run the application:
 chat-cli
 ```
 
+### Testing Reasoning Models
+
+To test the OpenAI reasoning models implementation, you can use the included test script:
+```
+./test_reasoning.py
+```
+
+This script will test both completion and streaming with the available reasoning models.
+
+### About OpenAI Reasoning Models
+
+OpenAI's reasoning models (o1, o3, o4-mini, etc.) are LLMs trained with reinforcement learning to perform reasoning. These models:
+
+- Think before they answer, producing a long internal chain of thought
+- Excel in complex problem solving, coding, scientific reasoning, and multi-step planning
+- Use "reasoning tokens" to work through problems step by step before providing a response
+- Support different reasoning effort levels (low, medium, high)
+
+The implementation in this CLI supports both standard completions and streaming with these models.
+
 ### Keyboard Shortcuts
 
 - `q` - Quit the application

{chat_console-0.3.995 → chat_console-0.4.0}/app/__init__.py

@@ -3,4 +3,4 @@ Chat CLI
 A command-line interface for chatting with various LLM providers like ChatGPT and Claude.
 """
 
-__version__ = "0.3.995"
+__version__ = "0.4.0"

{chat_console-0.3.995 → chat_console-0.4.0}/app/api/base.py

@@ -82,9 +82,9 @@ class BaseModelClient(ABC):
             
             # If we couldn't get the provider from the UI, infer it from the model name
             # Check for common OpenAI model patterns or prefixes
-            if (model_name_lower.startswith(("gpt-", "text-", "davinci")) or 
+            if (model_name_lower.startswith(("gpt-", "text-", "davinci", "o1", "o3", "o4")) or 
                 "gpt" in model_name_lower or 
-                model_name_lower in ["04-mini", "04", "04-turbo", "04-vision"]):
+                model_name_lower in ["04-mini", "04", "04-turbo", "04-vision", "o1", "o3", "o4-mini"]):
                 provider = "openai"
                 logger.info(f"Identified {model_name} as an OpenAI model")
             # Then check for Anthropic models - these should ALWAYS use Anthropic client
@@ -162,9 +162,9 @@ class BaseModelClient(ABC):
             # If we couldn't get the provider from the UI, infer it from the model name
             if not provider:
                 # Check for common OpenAI model patterns or prefixes
-                if (model_name_lower.startswith(("gpt-", "text-", "davinci")) or 
+                if (model_name_lower.startswith(("gpt-", "text-", "davinci", "o1", "o3", "o4")) or 
                     "gpt" in model_name_lower or 
-                    model_name_lower in ["04-mini", "04", "04-turbo", "04-vision"]):
+                    model_name_lower in ["04-mini", "04", "04-turbo", "04-vision", "o1", "o3", "o4-mini"]):
                     if not AVAILABLE_PROVIDERS["openai"]:
                         raise Exception("OpenAI API key not found. Please set OPENAI_API_KEY environment variable.")
                     provider = "openai"

{chat_console-0.3.995 → chat_console-0.4.0}/app/api/openai.py

@@ -53,20 +53,38 @@ class OpenAIClient(BaseModelClient):
         """Generate a text completion using OpenAI"""
         processed_messages = self._prepare_messages(messages, style)
         
-        # Create parameters dict, omitting max_tokens if it's None
-        params = {
-            "model": model,
-            "messages": processed_messages,
-            "temperature": temperature,
-        }
-        
-        # Only add max_tokens if it's not None
-        if max_tokens is not None:
-            params["max_tokens"] = max_tokens
-        
-        response = await self.client.chat.completions.create(**params)
+        # Check if this is a reasoning model (o-series)
+        is_reasoning_model = model.startswith(("o1", "o3", "o4")) or model in ["o1", "o3", "o4-mini"]
         
-        return response.choices[0].message.content
+        # Use the Responses API for reasoning models
+        if is_reasoning_model:
+            # Create parameters dict for the Responses API
+            params = {
+                "model": model,
+                "input": processed_messages,
+                "reasoning": {"effort": "medium"},  # Default to medium effort
+            }
+            
+            # Only add max_tokens if it's not None
+            if max_tokens is not None:
+                params["max_output_tokens"] = max_tokens
+            
+            response = await self.client.responses.create(**params)
+            return response.output_text
+        else:
+            # Use the Chat Completions API for non-reasoning models
+            params = {
+                "model": model,
+                "messages": processed_messages,
+                "temperature": temperature,
+            }
+            
+            # Only add max_tokens if it's not None
+            if max_tokens is not None:
+                params["max_tokens"] = max_tokens
+            
+            response = await self.client.chat.completions.create(**params)
+            return response.choices[0].message.content
     
     async def generate_stream(self, messages: List[Dict[str, str]], 
                             model: str, 
@@ -83,6 +101,9 @@ class OpenAIClient(BaseModelClient):
             
         processed_messages = self._prepare_messages(messages, style)
         
+        # Check if this is a reasoning model (o-series)
+        is_reasoning_model = model.startswith(("o1", "o3", "o4")) or model in ["o1", "o3", "o4-mini"]
+        
         try:
             debug_log(f"OpenAI: preparing {len(processed_messages)} messages for stream")
             
@@ -119,20 +140,37 @@ class OpenAIClient(BaseModelClient):
             
             while retry_count <= max_retries:
                 try:
-                    # Create parameters dict, omitting max_tokens if it's None
-                    params = {
-                        "model": model,
-                        "messages": api_messages,
-                        "temperature": temperature,
-                        "stream": True,
-                    }
-                    
-                    # Only add max_tokens if it's not None
-                    if max_tokens is not None:
-                        params["max_tokens"] = max_tokens
-                    
-                    debug_log(f"OpenAI: creating stream with params: {params}")
-                    stream = await self.client.chat.completions.create(**params)
+                    # Create parameters dict based on model type
+                    if is_reasoning_model:
+                        # Use the Responses API for reasoning models
+                        params = {
+                            "model": model,
+                            "input": api_messages,
+                            "reasoning": {"effort": "medium"},  # Default to medium effort
+                            "stream": True,
+                        }
+                        
+                        # Only add max_tokens if it's not None
+                        if max_tokens is not None:
+                            params["max_output_tokens"] = max_tokens
+                        
+                        debug_log(f"OpenAI: creating reasoning model stream with params: {params}")
+                        stream = await self.client.responses.create(**params)
+                    else:
+                        # Use the Chat Completions API for non-reasoning models
+                        params = {
+                            "model": model,
+                            "messages": api_messages,
+                            "temperature": temperature,
+                            "stream": True,
+                        }
+                        
+                        # Only add max_tokens if it's not None
+                        if max_tokens is not None:
+                            params["max_tokens"] = max_tokens
+                        
+                        debug_log(f"OpenAI: creating chat completion stream with params: {params}")
+                        stream = await self.client.chat.completions.create(**params)
                     
                     # Store the stream for potential cancellation
                     self._active_stream = stream
@@ -157,17 +195,28 @@ class OpenAIClient(BaseModelClient):
                             
                         chunk_count += 1
                         try:
-                            if chunk.choices and hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
-                                content = chunk.choices[0].delta.content
-                                if content is not None:
-                                    # Ensure we're returning a string
-                                    text = str(content)
-                                    debug_log(f"OpenAI: yielding chunk {chunk_count} of length: {len(text)}")
+                            # Handle different response formats based on model type
+                            if is_reasoning_model:
+                                # For reasoning models using the Responses API
+                                if hasattr(chunk, 'output_text') and chunk.output_text is not None:
+                                    text = str(chunk.output_text)
+                                    debug_log(f"OpenAI reasoning: yielding chunk {chunk_count} of length: {len(text)}")
                                     yield text
                                 else:
-                                    debug_log(f"OpenAI: skipping None content chunk {chunk_count}")
+                                    debug_log(f"OpenAI reasoning: skipping chunk {chunk_count} with missing content")
                             else:
-                                debug_log(f"OpenAI: skipping chunk {chunk_count} with missing content")
+                                # For regular models using the Chat Completions API
+                                if chunk.choices and hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
+                                    content = chunk.choices[0].delta.content
+                                    if content is not None:
+                                        # Ensure we're returning a string
+                                        text = str(content)
+                                        debug_log(f"OpenAI: yielding chunk {chunk_count} of length: {len(text)}")
+                                        yield text
+                                    else:
+                                        debug_log(f"OpenAI: skipping None content chunk {chunk_count}")
+                                else:
+                                    debug_log(f"OpenAI: skipping chunk {chunk_count} with missing content")
                         except Exception as chunk_error:
                             debug_log(f"OpenAI: error processing chunk {chunk_count}: {str(chunk_error)}")
                             # Skip problematic chunks but continue processing
@@ -221,11 +270,32 @@ class OpenAIClient(BaseModelClient):
             for model in models_response.data:
                 # Use 'id' as both id and name for now; can enhance with more info if needed
                 models.append({"id": model.id, "name": model.id})
+            
+            # Add reasoning models which might not be in the models list
+            reasoning_models = [
+                {"id": "o1", "name": "o1 (Reasoning)"},
+                {"id": "o1-mini", "name": "o1-mini (Reasoning)"},
+                {"id": "o3", "name": "o3 (Reasoning)"},
+                {"id": "o3-mini", "name": "o3-mini (Reasoning)"},
+                {"id": "o4-mini", "name": "o4-mini (Reasoning)"}
+            ]
+            
+            # Add reasoning models if they're not already in the list
+            existing_ids = {model["id"] for model in models}
+            for reasoning_model in reasoning_models:
+                if reasoning_model["id"] not in existing_ids:
+                    models.append(reasoning_model)
+                    
             return models
         except Exception as e:
             # Fallback to a static list if API call fails
             return [
                 {"id": "gpt-3.5-turbo", "name": "gpt-3.5-turbo"},
                 {"id": "gpt-4", "name": "gpt-4"},
-                {"id": "gpt-4-turbo", "name": "gpt-4-turbo"}
+                {"id": "gpt-4-turbo", "name": "gpt-4-turbo"},
+                {"id": "o1", "name": "o1 (Reasoning)"},
+                {"id": "o1-mini", "name": "o1-mini (Reasoning)"},
+                {"id": "o3", "name": "o3 (Reasoning)"},
+                {"id": "o3-mini", "name": "o3-mini (Reasoning)"},
+                {"id": "o4-mini", "name": "o4-mini (Reasoning)"}
             ]

{chat_console-0.3.995 → chat_console-0.4.0}/app/config.py

@@ -52,6 +52,31 @@ DEFAULT_CONFIG = {
             "max_tokens": 8192,
             "display_name": "GPT-4"
         },
+        "o1": {
+            "provider": "openai",
+            "max_tokens": 128000,
+            "display_name": "o1 (Reasoning)"
+        },
+        "o1-mini": {
+            "provider": "openai",
+            "max_tokens": 128000,
+            "display_name": "o1-mini (Reasoning)"
+        },
+        "o3": {
+            "provider": "openai",
+            "max_tokens": 128000,
+            "display_name": "o3 (Reasoning)"
+        },
+        "o3-mini": {
+            "provider": "openai",
+            "max_tokens": 128000,
+            "display_name": "o3-mini (Reasoning)"
+        },
+        "o4-mini": {
+            "provider": "openai",
+            "max_tokens": 128000,
+            "display_name": "o4-mini (Reasoning)"
+        },
         # Use the corrected keys from anthropic.py
         "claude-3-opus-20240229": {
             "provider": "anthropic",

{chat_console-0.3.995 → chat_console-0.4.0}/app/utils.py

@@ -65,12 +65,25 @@ async def generate_conversation_title(message: str, model: str, client: Any) ->
         
         # Generate title
         debug_log(f"Sending title generation request to {title_model}")
-        title = await title_client.generate_completion(
-            messages=title_prompt,
-            model=title_model,
-            temperature=0.7,
-            max_tokens=60
-        )
+        
+        # Check if this is a reasoning model (o-series)
+        is_reasoning_model = title_model.startswith(("o1", "o3", "o4")) or title_model in ["o1", "o3", "o4-mini"]
+        
+        if is_reasoning_model:
+            # For reasoning models, don't include temperature
+            title = await title_client.generate_completion(
+                messages=title_prompt,
+                model=title_model,
+                max_tokens=60
+            )
+        else:
+            # For non-reasoning models, include temperature
+            title = await title_client.generate_completion(
+                messages=title_prompt,
+                model=title_model,
+                temperature=0.7,
+                max_tokens=60
+            )
         
         # Sanitize the title
         title = title.strip().strip('"\'').strip()
@@ -755,7 +768,13 @@ def resolve_model_id(model_id_or_name: str) -> str:
         "35-turbo": "gpt-3.5-turbo",
         "35": "gpt-3.5-turbo",
         "4.1-mini": "gpt-4.1-mini",  # Add support for gpt-4.1-mini
-        "4.1": "gpt-4.1"  # Add support for gpt-4.1
+        "4.1": "gpt-4.1",  # Add support for gpt-4.1
+        # Add support for reasoning models
+        "o1": "o1",
+        "o1-mini": "o1-mini",
+        "o3": "o3",
+        "o3-mini": "o3-mini",
+        "o4-mini": "o4-mini"
     }
     
     if input_lower in openai_model_aliases:
@@ -765,23 +784,26 @@ def resolve_model_id(model_id_or_name: str) -> str:
     
     # Special case handling for common typos and model name variations
     typo_corrections = {
-        "o4-mini": "04-mini",
-        "o1": "01",
-        "o1-mini": "01-mini",
-        "o1-preview": "01-preview",
-        "o4": "04",
-        "o4-preview": "04-preview",
-        "o4-vision": "04-vision"
+        # Keep reasoning models as-is, don't convert 'o' to '0'
+        # "o4-mini": "04-mini",
+        # "o1": "01",
+        # "o1-mini": "01-mini",
+        # "o1-preview": "01-preview",
+        # "o4": "04",
+        # "o4-preview": "04-preview",
+        # "o4-vision": "04-vision"
     }
     
+    # Don't convert reasoning model IDs that start with 'o'
     # Check for more complex typo patterns with dates
-    if input_lower.startswith("o1-") and "-202" in input_lower:
+    if input_lower.startswith("o1-") and "-202" in input_lower and not any(input_lower == model_id for model_id in ["o1", "o1-mini", "o3", "o3-mini", "o4-mini"]):
         corrected = "01" + input_lower[2:]
         logger.info(f"Converting '{input_lower}' to '{corrected}' (letter 'o' to zero '0')")
         input_lower = corrected
         model_id_or_name = corrected
     
-    if input_lower in typo_corrections:
+    # Only apply typo corrections if not a reasoning model
+    if input_lower in typo_corrections and not any(input_lower == model_id for model_id in ["o1", "o1-mini", "o3", "o3-mini", "o4-mini"]):
         corrected = typo_corrections[input_lower]
         logger.info(f"Converting '{input_lower}' to '{corrected}' (letter 'o' to zero '0')")
         input_lower = corrected

{chat_console-0.3.995 → chat_console-0.4.0/chat_console.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chat-console
-Version: 0.3.995
+Version: 0.4.0
 Summary: A command-line interface for chatting with LLMs, storing chats and (future) rag interactions
 Home-page: https://github.com/wazacraftrfid/chat-console
 Author: Johnathan Greenaway
@@ -28,7 +28,8 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# Chat CLI
+
+c# Chat CLI
 
 A comprehensive command-line interface for chatting with various AI language models. This application allows you to interact with different LLM providers through an intuitive terminal-based interface.
 
@@ -37,6 +38,7 @@ A comprehensive command-line interface for chatting with various AI language mod
 - Interactive terminal UI with Textual library
 - Support for multiple AI models:
   - OpenAI models (GPT-3.5, GPT-4)
+  - OpenAI reasoning models (o1, o1-mini, o3, o3-mini, o4-mini)
   - Anthropic models (Claude 3 Opus, Sonnet, Haiku)
 - Conversation history with search functionality
 - Customizable response styles (concise, detailed, technical, friendly)
@@ -71,6 +73,26 @@ Run the application:
 chat-cli
 ```
 
+### Testing Reasoning Models
+
+To test the OpenAI reasoning models implementation, you can use the included test script:
+```
+./test_reasoning.py
+```
+
+This script will test both completion and streaming with the available reasoning models.
+
+### About OpenAI Reasoning Models
+
+OpenAI's reasoning models (o1, o3, o4-mini, etc.) are LLMs trained with reinforcement learning to perform reasoning. These models:
+
+- Think before they answer, producing a long internal chain of thought
+- Excel in complex problem solving, coding, scientific reasoning, and multi-step planning
+- Use "reasoning tokens" to work through problems step by step before providing a response
+- Support different reasoning effort levels (low, medium, high)
+
+The implementation in this CLI supports both standard completions and streaming with these models.
+
 ### Keyboard Shortcuts
 
 - `q` - Quit the application