webscout 6.0__py3-none-any.whl → 6.2__py3-none-any.whl

webscout/Local/thread.py

@@ -1,78 +1,73 @@
-import json
-from ._version import __version__, __llama_cpp_version__
-
-"""Submodule containing the Thread class, used for interaction with a Model"""
-
 import sys
+import time
+from typing import Optional, Literal, Union, Generator, Tuple, TextIO
+import uuid  
 
-from .model    import Model, assert_model_is_loaded, _SupportsWriteAndFlush
-from .utils    import RESET_ALL, cls, print_verbose, truncate
+from .model import Model, assert_model_is_loaded, _SupportsWriteAndFlush
+from .utils import RESET_ALL, cls, print_verbose, truncate
 from .samplers import SamplerSettings, DefaultSampling
-from typing    import Optional, Literal, Union
-from .formats  import AdvancedFormat
-
-from .formats import blank as formats_blank
+from .formats import AdvancedFormat, blank as formats_blank
 
 
 class Message(dict):
     """
-    A dictionary representing a single message within a Thread
+    Represents a single message within a Thread.
 
-    Works just like a normal `dict`, but a new method:
-    - `.as_string` - Return the full message string
+    Inherits from `dict` and provides additional functionality:
 
-    Generally, messages have these keys:
-    - `role` -  The role of the speaker: 'system', 'user', or 'bot'
-    - `prefix` - The text that prefixes the message content
-    - `content` - The actual content of the message
-    - `suffix` - The text that suffixes the message content
+    - `as_string()`: Returns the full message string.
+
+    Typical message keys:
+    - `role`: The speaker's role ('system', 'user', 'bot').
+    - `prefix`: Text prefixing the content.
+    - `content`: The message content.
+    - `suffix`: Text suffixing the content.
     """
 
     def __repr__(self) -> str:
-        return \
-            f"Message([" \
-            f"('role', {repr(self['role'])}), " \
-            f"('prefix', {repr(self['prefix'])}), " \
-            f"('content', {repr(self['content'])}), " \
+        return (
+            f"Message(["
+            f"('role', {repr(self['role'])}), "
+            f"('prefix', {repr(self['prefix'])}), "
+            f"('content', {repr(self['content'])}), "
             f"('suffix', {repr(self['suffix'])})])"
+        )
 
-    def as_string(self):
-        """Return the full message string"""
+    def as_string(self) -> str:
+        """Returns the full message string."""
         try:
             return self['prefix'] + self['content'] + self['suffix']
         except KeyError as e:
             e.add_note(
-                "as_string: Message is missing one or more of the "
-                "required 'prefix', 'content', 'suffix' attributes - this is "
-                "unexpected"
+                "Message.as_string(): Missing 'prefix', 'content', or 'suffix' "
+                "attribute. This is unexpected."
             )
             raise e
 
 
 class Thread:
     """
-    Provide functionality to facilitate easy interactions with a Model
-
-    This is just a brief overview of m.Thread.
-    To see a full description of each method and its parameters,
-    call help(Thread), or see the relevant docstring.
-
-    The following methods are available:
-    - `.add_message()` - Add a message to `Thread.messages`
-    - `.as_string()` - Return this thread's complete message history as a string
-    - `.create_message()` - Create a message using the format of this thread
-    - `.inference_str_from_messages()` - Using the list of messages, return a string suitable for inference
-    - `.interact()` - Start an interactive, terminal-based chat session
-    - `.len_messages()` - Get the total length of all messages in tokens
-    - `.print_stats()` - Print stats about the context usage in this thread
-    - `.reset()` - Clear the list of messages
-    - `.send()` - Send a message in this thread
-
-    The following attributes are available:
-    - `.format` - The format being used for messages in this thread
-    - `.messages` - The list of messages in this thread
-    - `.model` - The `m.Model` instance used by this thread
-    - `.sampler` - The SamplerSettings object used in this thread
+    Facilitates easy interactions with a Model.
+
+    Methods:
+    - `add_message()`: Appends a message to the thread's messages.
+    - `as_string()`: Returns the complete message history as a string.
+    - `create_message()`: Creates a message using the thread's format.
+    - `inference_str_from_messages()`: Generates an inference-ready string from messages.
+    - `interact()`: Starts an interactive chat session.
+    - `len_messages()`: Gets the total token length of all messages.
+    - `print_stats()`: Prints context usage statistics.
+    - `reset()`: Clears the message history.
+    - `send()`: Sends a message and receives a response.
+    - `warmup()`: Warms up the model by running a simple generation.
+
+    Attributes:
+    - `format`: The message format (see `webscout.AIutel.formats`).
+    - `messages`: The list of messages in the thread.
+    - `model`: The associated `webscout.AIutel.model.Model` instance.
+    - `sampler`: The `webscout.AIutel.samplers.SamplerSettings` for text generation.
+    - `tools`: A list of tools available for function calling.
+    - `uuid`: A unique identifier for the thread (UUID object).
     """
 
     def __init__(
@@ -81,24 +76,18 @@ class Thread:
         format: Union[dict, AdvancedFormat],
         sampler: SamplerSettings = DefaultSampling,
         messages: Optional[list[Message]] = None,
-
     ):
-    
         """
-        Given a Model and a format, construct a Thread instance.
+        Initializes a Thread instance.
 
-        model: The Model to use for text generation
-        format: The format specifying how messages should be structured (see m.formats)
-
-        The following parameters are optional:
-        - sampler: The SamplerSettings object used to control text generation
-        - messages: A list of m.thread.Message objects to add to the Thread upon construction
+        Args:
+            model: The Model instance for text generation.
+            format: The message format (see `webscout.AIutel.formats`).
+            sampler: Sampler settings for controlling generation.
+            messages: Initial list of messages (optional).
         """
-        
         assert isinstance(model, Model), \
-            "Thread: model should be an " + \
-            f"instance of webscout.Local.Model, not {type(model)}"
-        
+            f"Thread: model should be a webscout.AIutel.model.Model, not {type(model)}"
         assert_model_is_loaded(model)
 
         assert isinstance(format, (dict, AdvancedFormat)), \
@@ -106,23 +95,17 @@ class Thread:
         
         if any(k not in format.keys() for k in formats_blank.keys()):
             raise KeyError(
-                "Thread: format is missing one or more required keys, see " + \
-                "webscout.Local.formats.blank for an example"
+                "Thread: format is missing one or more required keys, see "
+                "webscout.AIutel.formats.blank for an example"
             )
 
         assert isinstance(format['stops'], list), \
-            "Thread: format['stops'] should be list, not " + \
-            f"{type(format['stops'])}"
+            f"Thread: format['stops'] should be list, not {type(format['stops'])}"
         
         assert all(
             hasattr(sampler, attr) for attr in [
-                'max_len_tokens',
-                'temp',
-                'top_p',
-                'min_p',
-                'frequency_penalty',
-                'presence_penalty',
-                'repeat_penalty',
+                'max_len_tokens', 'temp', 'top_p', 'min_p',
+                'frequency_penalty', 'presence_penalty', 'repeat_penalty',
                 'top_k'
             ]
         ), 'Thread: sampler is missing one or more required attributes'
@@ -132,30 +115,29 @@ class Thread:
             if not all(isinstance(msg, Message) for msg in self._messages):
                 raise TypeError(
                     "Thread: one or more messages provided to __init__() is "
-                    "not an instance of m.thread.Message"
+                    "not an instance of webscout.AIutel.thread.Message"
                 )
-        
-        # Thread.messages is never empty, unless `messages` param is explicity
-        # set to `[]` during construction
 
-        self.model: Model = model
-        self.format: Union[dict, AdvancedFormat] = format
+        self.model = model
+        self.format = format
         self.messages: list[Message] = [
-            self.create_message("system", self.format['system_content'])
+            self.create_message("system", self.format['system_prompt'])
         ] if self._messages is None else self._messages
-        self.sampler: SamplerSettings = sampler
-        self.tools = [] 
+        self.sampler = sampler
+        self.tools = []
+        self.uuid = uuid.uuid4()  # Generate a UUID for the thread
+
         if self.model.verbose:
-            print_verbose("new Thread instance with the following attributes:")
+            print_verbose("New Thread instance with attributes:")
             print_verbose(f"model                     == {self.model}")
             print_verbose(f"format['system_prefix']   == {truncate(repr(self.format['system_prefix']))}")
-            print_verbose(f"format['system_content']  == {truncate(repr(self.format['system_content']))}")
+            print_verbose(f"format['system_prompt']  == {truncate(repr(self.format['system_prompt']))}")
             print_verbose(f"format['system_suffix']   == {truncate(repr(self.format['system_suffix']))}")
             print_verbose(f"format['user_prefix']     == {truncate(repr(self.format['user_prefix']))}")
-            print_verbose(f"format['user_content']    == {truncate(repr(self.format['user_content']))}")
+            # print_verbose(f"format['user_content']    == {truncate(repr(self.format['user_content']))}")
             print_verbose(f"format['user_suffix']     == {truncate(repr(self.format['user_suffix']))}")
             print_verbose(f"format['bot_prefix']      == {truncate(repr(self.format['bot_prefix']))}")
-            print_verbose(f"format['bot_content']     == {truncate(repr(self.format['bot_content']))}")
+            # print_verbose(f"format['bot_content']     == {truncate(repr(self.format['bot_content']))}")
             print_verbose(f"format['bot_suffix']      == {truncate(repr(self.format['bot_suffix']))}")
             print_verbose(f"format['stops']           == {truncate(repr(self.format['stops']))}")
             print_verbose(f"sampler.temp              == {self.sampler.temp}")
@@ -165,126 +147,85 @@ class Thread:
             print_verbose(f"sampler.presence_penalty  == {self.sampler.presence_penalty}")
             print_verbose(f"sampler.repeat_penalty    == {self.sampler.repeat_penalty}")
             print_verbose(f"sampler.top_k             == {self.sampler.top_k}")
-    def add_tool(self, tool: dict):
-        """Adds a tool to the Thread for function calling."""
+
+    def add_tool(self, tool: dict) -> None:
+        """
+        Adds a tool to the Thread for function calling.
+
+        Args:
+            tool (dict): A dictionary describing the tool, containing
+                         'function' with 'name', 'description', and 'execute' keys.
+        """
         self.tools.append(tool)
-        self.model.register_tool(tool['function']['name'], tool['function']['execute']) # Register the tool
+        self.model.register_tool(tool['function']['name'], tool['function']['execute'])
+        self.messages[0]['content'] += f"\nYou have access to the following tool:\n{tool['function']['description']}"
 
-        # Include tool information in the system message (optional, but helpful)
-        self.messages[0]['content'] += f"\nYou have access to the following tool:\n{tool['function']['description']}" 
     def __repr__(self) -> str:
-        return \
-            f"Thread({repr(self.model)}, {repr(self.format)}, " + \
+        return (
+            f"Thread({repr(self.model)}, {repr(self.format)}, "
             f"{repr(self.sampler)}, {repr(self.messages)})"
-    
+        )
+
     def __str__(self) -> str:
         return self.as_string()
-    
-    def __len__(self) -> int:
-        """
-        `len(Thread)` returns the length of the Thread in tokens
 
-        To get the number of messages in the Thread, use `len(Thread.messages)`
-        """
+    def __len__(self) -> int:
+        """Returns the total token length of all messages."""
         return self.len_messages()
 
-    def create_message(
-        self,
-        role: Literal['system', 'user', 'bot'],
-        content: str
-    ) -> Message:
-        """
-        Construct a message using the format of this Thread
-        """
-
+    def create_message(self, role: Literal['system', 'user', 'bot'], content: str) -> Message:
+        """Constructs a message using the thread's format."""
         assert role.lower() in ['system', 'user', 'bot'], \
-            f"create_message: role should be 'system', 'user', or 'bot', not '{role.lower()}'"
-
+            f"Thread.create_message(): role should be 'system', 'user', or 'bot', not '{role.lower()}'"
         assert isinstance(content, str), \
-            f"create_message: content should be str, not {type(content)}"
-
-        if role.lower() == 'system':
-            return Message(
-                [
-                    ('role', 'system'),
-                    ('prefix', self.format['system_prefix']),
-                    ('content', content),
-                    ('suffix', self.format['system_suffix'])
-                ]
-            )
-        
-        elif role.lower() == 'user':
-            return Message(
-                [
-                    ('role', 'user'),
-                    ('prefix', self.format['user_prefix']),
-                    ('content', content),
-                    ('suffix', self.format['user_suffix'])
-                ]
-            )
-        
-        elif role.lower() == 'bot':
-            return Message(
-                [
-                    ('role', 'bot'),
-                    ('prefix', self.format['bot_prefix']),
-                    ('content', content),
-                    ('suffix', self.format['bot_suffix'])
-                ]
-            )
-    
-    def len_messages(self) -> int:
-        """
-        Return the total length of all messages in this thread, in tokens.
-        
-        Can also use `len(Thread)`."""
+            f"Thread.create_message(): content should be str, not {type(content)}"
+
+        message_data = {
+            'system': {
+                'role': 'system',
+                'prefix': self.format['system_prefix'],
+                'content': content,
+                'suffix': self.format['system_suffix']
+            },
+            'user': {
+                'role': 'user',
+                'prefix': self.format['user_prefix'],
+                'content': content,
+                'suffix': self.format['user_suffix']
+            },
+            'bot': {
+                'role': 'bot',
+                'prefix': self.format['bot_prefix'],
+                'content': content,
+                'suffix': self.format['bot_suffix']
+            }
+        }
+
+        return Message(message_data[role.lower()])
 
+    def len_messages(self) -> int:
+        """Returns the total length of all messages in tokens."""
         return self.model.get_length(self.as_string())
 
-    def add_message(
-        self,
-        role: Literal['system', 'user', 'bot'],
-        content: str
-    ) -> None:
-        """
-        Create a message and append it to `Thread.messages`.
-
-        `Thread.add_message(...)` is a shorthand for
-        `Thread.messages.append(Thread.create_message(...))`
-        """
-        self.messages.append(
-            self.create_message(
-                role=role,
-                content=content
-            )
-        )
+    def add_message(self, role: Literal['system', 'user', 'bot'], content: str) -> None:
+        """Appends a message to the thread's messages."""
+        self.messages.append(self.create_message(role, content))
 
     def inference_str_from_messages(self) -> str:
-        """
-        Using the list of messages, construct a string suitable for inference,
-        respecting the format and context length of this thread.
-        """
-
+        """Constructs an inference-ready string from messages."""
         inf_str = ''
         sys_msg_str = ''
-        # whether to treat the first message as necessary to keep
         sys_msg_flag = False
         context_len_budget = self.model.context_length
 
-        # if at least 1 message is history
-        if len(self.messages) >= 1:
-            # if first message has system role
-            if self.messages[0]['role'] == 'system':
-                sys_msg_flag = True
-                sys_msg = self.messages[0]
-                sys_msg_str = sys_msg.as_string()
-                context_len_budget -= self.model.get_length(sys_msg_str)
-
-        if sys_msg_flag:
-            iterator = reversed(self.messages[1:])
-        else:
-            iterator = reversed(self.messages)
-        
+        if len(self.messages) >= 1 and self.messages[0]['role'] == 'system':
+            sys_msg_flag = True
+            sys_msg = self.messages[0]
+            sys_msg_str = sys_msg.as_string()
+            context_len_budget -= self.model.get_length(sys_msg_str)
+
+        iterator = reversed(self.messages[1:]) if sys_msg_flag else reversed(self.messages)
+
         for message in iterator:
             msg_str = message.as_string()
             context_len_budget -= self.model.get_length(msg_str)
@@ -292,21 +233,13 @@ class Thread:
                 break
             inf_str = msg_str + inf_str
 
-        if sys_msg_flag:
-            inf_str = sys_msg_str + inf_str
+        inf_str = sys_msg_str + inf_str if sys_msg_flag else inf_str
         inf_str += self.format['bot_prefix']
 
         return inf_str
 
-
     def send(self, prompt: str) -> str:
-        """
-        Send a message in this thread. This adds your message and the bot's
-        response to the list of messages.
-
-        Returns a string containing the response to your message.
-        """
-
+        """Sends a message and receives a response."""
         self.add_message("user", prompt)
         output = self.model.generate(
             self.inference_str_from_messages(),
@@ -314,85 +247,28 @@ class Thread:
             sampler=self.sampler
         )
         self.add_message("bot", output)
-
         return output
-    
 
     def _interactive_update_sampler(self) -> None:
-        """Interactively update the sampler settings used in this Thread"""
+        """Interactively updates sampler settings."""
         print()
         try:
-            new_max_len_tokens = input(f'max_len_tokens: {self.sampler.max_len_tokens} -> ')
-            new_temp = input(f'temp: {self.sampler.temp} -> ')
-            new_top_p = input(f'top_p: {self.sampler.top_p} -> ')
-            new_min_p = input(f'min_p: {self.sampler.min_p} -> ')
-            new_frequency_penalty = input(f'frequency_penalty: {self.sampler.frequency_penalty} -> ')
-            new_presence_penalty = input(f'presence_penalty: {self.sampler.presence_penalty} -> ')
-            new_repeat_penalty = input(f'repeat_penalty: {self.sampler.repeat_penalty} -> ')
-            new_top_k = input(f'top_k: {self.sampler.top_k} -> ')
-        
+            for param_name in SamplerSettings.param_types:
+                current_value = getattr(self.sampler, param_name)
+                new_value = input(f'{param_name}: {current_value} -> ')
+                try:
+                    if new_value.lower() == 'none':
+                        setattr(self.sampler, param_name, None)
+                    elif param_name in ('top_k', 'max_len_tokens'):
+                        setattr(self.sampler, param_name, int(new_value))
+                    else:
+                        setattr(self.sampler, param_name, float(new_value))
+                    print(f'webscout.AIutel: {param_name} updated')
+                except ValueError:
+                    print(f'webscout.AIutel: {param_name} not updated (invalid input)')
+            print()
         except KeyboardInterrupt:
-            print('\nwebscout.Local: sampler settings not updated\n')
-            return
-        print()
-
-        try:
-            self.sampler.max_len_tokens = int(new_max_len_tokens)
-        except ValueError:
-            pass
-        else:
-            print('webscout.Local: max_len_tokens updated')
-        
-        try:
-            self.sampler.temp = float(new_temp)
-        except ValueError:
-            pass
-        else:
-            print('webscout.Local: temp updated')
-        
-        try:
-            self.sampler.top_p = float(new_top_p)
-        except ValueError:
-            pass
-        else:
-            print('webscout.Local: top_p updated')
-
-        try:
-            self.sampler.min_p = float(new_min_p)
-        except ValueError:
-            pass
-        else:
-            print('webscout.Local: min_p updated')
-
-        try:
-            self.sampler.frequency_penalty = float(new_frequency_penalty)
-        except ValueError:
-            pass
-        else:
-            print('webscout.Local: frequency_penalty updated')
-        
-        try:
-            self.sampler.presence_penalty = float(new_presence_penalty)
-        except ValueError:
-            pass
-        else:
-            print('webscout.Local: presence_penalty updated')
-        
-        try:
-            self.sampler.repeat_penalty = float(new_repeat_penalty)
-        except ValueError:
-            pass
-        else:
-            print('webscout.Local: repeat_penalty updated')
-        
-        try:
-            self.sampler.top_k = int(new_top_k)
-        except ValueError:
-            pass
-        else:
-            print('webscout.Local: top_k updated')
-        print()
-                
+            print('\nwebscout.AIutel: Sampler settings not updated\n')
 
     def _interactive_input(
         self,
@@ -401,21 +277,20 @@ class Thread:
         _user_style: str,
         _bot_style: str,
         _special_style: str
-    ) -> tuple:
-        """
-        Recive input from the user, while handling multi-line input
-        and commands
-        """
-        full_user_input = '' # may become multiline
+    ) -> Tuple[Optional[str], Optional[str]]:
+        """Receives input from the user, handling multi-line input and commands."""
+        full_user_input = ''
         
         while True:
-            user_input = input(prompt)
-            
+            try:
+                user_input = input(prompt)
+            except KeyboardInterrupt:
+                print(f"{RESET_ALL}\n")
+                return None, None
+
             if user_input.endswith('\\'):
                 full_user_input += user_input[:-1] + '\n'
-            
             elif user_input == '!':
-
                 print()
                 try:
                     command = input(f'{RESET_ALL}  ! {_dim_style}')
@@ -424,121 +299,105 @@ class Thread:
                     continue
 
                 if command == '':
-                    print(f'\n[no command]\n')
-
+                    print('\n[No command]\n')
                 elif command.lower() in ['reset', 'restart']:
                     self.reset()
-                    print(f'\n[thread reset]\n')
-
+                    print('\n[Thread reset]\n')
                 elif command.lower() in ['cls', 'clear']:
                     cls()
                     print()
-
                 elif command.lower() in ['ctx', 'context']:
                     print(f"\n{self.len_messages()}\n")
-
                 elif command.lower() in ['stats', 'print_stats']:
                     print()
                     self.print_stats()
                     print()
-                
                 elif command.lower() in ['sampler', 'samplers', 'settings']:
                     self._interactive_update_sampler()
-                
                 elif command.lower() in ['str', 'string', 'as_string']:
                     print(f"\n{self.as_string()}\n")
-                
                 elif command.lower() in ['repr', 'save', 'backup']:
                     print(f"\n{repr(self)}\n")
-                
                 elif command.lower() in ['remove', 'rem', 'delete', 'del']:
                     print()
-                    old_len = len(self.messages)
-                    del self.messages[-1]
-                    assert len(self.messages) == (old_len - 1)
-                    print('[removed last message]\n')
-
+                    if len(self.messages) > 1:  # Prevent deleting the system message
+                        old_len = len(self.messages)
+                        del self.messages[-1]
+                        assert len(self.messages) == (old_len - 1)
+                        print('[Removed last message]\n')
+                    else:
+                        print('[Cannot remove system message]\n')
                 elif command.lower() in ['last', 'repeat']:
-                    last_msg = self.messages[-1]
-                    if last_msg['role'] == 'user':
-                        print(f"\n{_user_style}{last_msg['content']}{RESET_ALL}\n")
-                    elif last_msg['role'] == 'bot':
-                        print(f"\n{_bot_style}{last_msg['content']}{RESET_ALL}\n")
-                
+                    if len(self.messages) > 1:
+                        last_msg = self.messages[-1]
+                        if last_msg['role'] == 'user':
+                            print(f"\n{_user_style}{last_msg['content']}{RESET_ALL}\n")
+                        elif last_msg['role'] == 'bot':
+                            print(f"\n{_bot_style}{last_msg['content']}{RESET_ALL}\n")
+                    else:
+                        print("\n[No previous message]\n")
                 elif command.lower() in ['inf', 'inference', 'inf_str']:
                     print(f'\n"""{self.inference_str_from_messages()}"""\n')
-                
                 elif command.lower() in ['reroll', 're-roll', 're', 'swipe']:
-                    old_len = len(self.messages)
-                    del self.messages[-1]
-                    assert len(self.messages) == (old_len - 1)
-                    return '', None
-                
+                    if len(self.messages) > 1:
+                        old_len = len(self.messages)
+                        del self.messages[-1]
+                        assert len(self.messages) == (old_len - 1)
+                        return '', None
+                    else:
+                        print("\n[Cannot reroll system message]\n")
                 elif command.lower() in ['exit', 'quit']:
                     print(RESET_ALL)
                     return None, None
-                
                 elif command.lower() in ['help', '/?', '?']:
-                    print()
-                    print('reset | restart     -- Reset the thread to its original state')
-                    print('clear | cls         -- Clear the terminal')
-                    print('context | ctx       -- Get the context usage in tokens')
-                    print('print_stats | stats -- Get the context usage stats')
-                    print('sampler | settings  -- Update the sampler settings')
-                    print('string | str        -- Print the message history as a string')
-                    print('repr | save         -- Print the representation of the thread')
-                    print('remove | delete     -- Remove the last message')
-                    print('last | repeat       -- Repeat the last message')
-                    print('inference | inf     -- Print the inference string')
-                    print('reroll | swipe      -- Regenerate the last message')
-                    print('exit | quit         -- Exit the interactive chat (can also use ^C)')
-                    print('help | ?            -- Show this screen')
-                    print()
-                    print("TIP: type < at the prompt and press ENTER to prefix the bot's next message.")
-                    print('     for example, type "Sure!" to bypass refusals')
-                    print()
-                    print("TIP: type !! at the prompt and press ENTER to insert a system message")
-                    print()
-
+                    print(
+                        "\n"
+                        "reset | restart     -- Reset the thread to its original state\n"
+                        "clear | cls         -- Clear the terminal\n"
+                        "context | ctx       -- Get the context usage in tokens\n"
+                        "print_stats | stats -- Get the context usage stats\n"
+                        "sampler | settings  -- Update the sampler settings\n"
+                        "string | str        -- Print the message history as a string\n"
+                        "repr | save         -- Print the representation of the thread\n"
+                        "remove | delete     -- Remove the last message\n"
+                        "last | repeat       -- Repeat the last message\n"
+                        "inference | inf     -- Print the inference string\n"
+                        "reroll | swipe      -- Regenerate the last message\n"
+                        "exit | quit         -- Exit the interactive chat (can also use ^C)\n"
+                        "help | ?            -- Show this screen\n"
+                        "\n"
+                        "TIP: Type '<' at the prompt and press ENTER to prefix the bot's next message.\n"
+                        "     For example, type 'Sure!' to bypass refusals\n"
+                        "\n"
+                        "TIP: Type '!!' at the prompt and press ENTER to insert a system message\n"
+                        "\n"
+                    )
                 else:
-                    print(f'\n[unknown command]\n')
-            
-            # prefix the bot's next message
+                    print('\n[Unknown command]\n')
             elif user_input == '<':
-
                 print()
                 try:
                     next_message_start = input(f'{RESET_ALL}  < {_dim_style}')
-
                 except KeyboardInterrupt:
                     print(f'{RESET_ALL}\n')
                     continue
-
                 else:
                     print()
                     return '', next_message_start
-
-            # insert a system message
             elif user_input == '!!':
                 print()
-
                 try:
                     next_sys_msg = input(f'{RESET_ALL} !! {_special_style}')
-                
                 except KeyboardInterrupt:
                     print(f'{RESET_ALL}\n')
                     continue
-                
                 else:
                     print()
-                    return next_sys_msg, -1
-
-            # concatenate multi-line input
+                    return next_sys_msg, '-1'
             else:
                 full_user_input += user_input
                 return full_user_input, None
 
-
     def interact(
         self,
         color: bool = True,
@@ -546,71 +405,46 @@ class Thread:
         stream: bool = True
     ) -> None:
         """
-        Start an interactive chat session using this Thread.
-
-        While text is being generated, press `^C` to interrupt the bot.
-        Then you have the option to press `ENTER` to re-roll, or to simply type
-        another message.
-
-        At the prompt, press `^C` to end the chat session.
-
-        Type `!` and press `ENTER` to enter a basic command prompt. For a list
-        of  commands, type `help` at this prompt.
-        
-        Type `<` and press `ENTER` to prefix the bot's next message, for
-        example with `Sure!`.
+        Starts an interactive chat session.
 
-        Type `!!` at the prompt and press `ENTER` to insert a system message.
+        Allows for real-time interaction with the model, including
+        interrupting generation, regenerating responses, and using
+        commands.
 
-        The following parameters are optional:
-        - color: Whether to use colored text to differentiate user / bot
-        - header: Header text to print at the start of the interaction
-        - stream: Whether to stream text as it is generated
+        Args:
+            color (bool, optional): Whether to use colored output. Defaults to True.
+            header (Optional[str], optional): Header text to display. Defaults to None.
+            stream (bool, optional): Whether to stream the response. Defaults to True.
         """
         print()
-
-        # fresh import of color codes in case `color` param has changed
         from .utils import SPECIAL_STYLE, USER_STYLE, BOT_STYLE, DIM_STYLE
-
-        # disable color codes if explicitly disabled by `color` param
         if not color:
-            SPECIAL_STYLE = ''
-            USER_STYLE = ''
-            BOT_STYLE = ''
-            DIM_STYLE = ''
+            SPECIAL_STYLE = USER_STYLE = BOT_STYLE = DIM_STYLE = ''
         
         if header is not None:
             print(f"{SPECIAL_STYLE}{header}{RESET_ALL}\n")
-        
-        while True:
 
+        while True:
             prompt = f"{RESET_ALL}  > {USER_STYLE}"
-            
             try:
                 user_prompt, next_message_start = self._interactive_input(
-                    prompt,
-                    DIM_STYLE,
-                    USER_STYLE,
-                    BOT_STYLE,
-                    SPECIAL_STYLE
+                    prompt, DIM_STYLE, USER_STYLE, BOT_STYLE, SPECIAL_STYLE
                 )
             except KeyboardInterrupt:
                 print(f"{RESET_ALL}\n")
                 return
             
-            # got 'exit' or 'quit' command
             if user_prompt is None and next_message_start is None:
                 break
-            
-            # insert a system message via `!!` prompt
-            if next_message_start == -1:
+
+            if next_message_start == '-1':
                 self.add_message('system', user_prompt)
                 continue
-            
+
             if next_message_start is not None:
                 try:
+                    print(f"{BOT_STYLE}{next_message_start}", end='', flush=True)
                     if stream:
-                        print(f"{BOT_STYLE}{next_message_start}", end='', flush=True)
                         output = next_message_start + self.model.stream_print(
                             self.inference_str_from_messages() + next_message_start,
                             stops=self.format['stops'],
@@ -618,7 +452,6 @@ class Thread:
                             end=''
                         )
                     else:
-                        print(f"{BOT_STYLE}", end='', flush=True)
                         output = next_message_start + self.model.generate(
                             self.inference_str_from_messages() + next_message_start,
                             stops=self.format['stops'],
@@ -626,12 +459,15 @@ class Thread:
                         )
                         print(output, end='', flush=True)
                 except KeyboardInterrupt:
-                    print(f"{DIM_STYLE} [message not added to history; press ENTER to re-roll]\n")
+                    print(
+                        f"{DIM_STYLE} [Message not added to history; "
+                        "press ENTER to re-roll]\n"
+                    )
                     continue
                 else:
                     self.add_message("bot", output)
             else:
-                print(BOT_STYLE)
+                print(BOT_STYLE, end='')
                 if user_prompt != "":
                     self.add_message("user", user_prompt)
                 try:
@@ -650,49 +486,54 @@ class Thread:
                         )
                         print(output, end='', flush=True)
                 except KeyboardInterrupt:
-                    print(f"{DIM_STYLE} [message not added to history; press ENTER to re-roll]\n")
+                    print(
+                        f"{DIM_STYLE} [Message not added to history; "
+                        "press ENTER to re-roll]\n"
+                    )
                     continue
                 else:
                     self.add_message("bot", output)
 
             if output.endswith("\n\n"):
-                print(RESET_ALL, end = '', flush=True)
+                print(RESET_ALL, end='', flush=True)
             elif output.endswith("\n"):
                 print(RESET_ALL)
             else:
                 print(f"{RESET_ALL}\n")
 
-
     def reset(self) -> None:
-        """
-        Clear the list of messages, which resets the thread to its original
-        state
-        """
+        """Clears the message history, resetting the thread to its initial state."""
         self.messages: list[Message] = [
-            self.create_message("system", self.format['system_content'])
+            self.create_message("system", self.format['system_prompt'])
         ] if self._messages is None else self._messages
-    
-    
+
     def as_string(self) -> str:
-        """Return this thread's message history as a string"""
-        thread_string = ''
-        for msg in self.messages:
-            thread_string += msg.as_string()
-        return thread_string
+        """Returns the thread's message history as a string."""
+        return ''.join(msg.as_string() for msg in self.messages)
 
-    
     def print_stats(
         self,
         end: str = '\n',
-        file: _SupportsWriteAndFlush = sys.stdout,
+        file: TextIO = sys.stdout,
         flush: bool = True
     ) -> None:
-        """Print stats about the context usage in this thread"""
+        """Prints context usage statistics."""
         thread_len_tokens = self.len_messages()
         max_ctx_len = self.model.context_length
-        context_used_percentage = round((thread_len_tokens/max_ctx_len)*100)
-        print(f"{thread_len_tokens} / {max_ctx_len} tokens", file=file, flush=flush)
-        print(f"{context_used_percentage}% of context used", file=file, flush=flush)
-        print(f"{len(self.messages)} messages", end=end, file=file, flush=flush)
+        context_used_percentage = round((thread_len_tokens / max_ctx_len) * 100)
+        print(
+            f"{thread_len_tokens} / {max_ctx_len} tokens "
+            f"({context_used_percentage}% of context used), "
+            f"{len(self.messages)} messages",
+            end=end, file=file, flush=flush
+        )
         if not flush:
-            file.flush()
+            file.flush()
+
+    def warmup(self):
+        """
+        Warms up the model by running a simple generation.
+        """
+        if self.model.verbose:
+            print_verbose("Warming up the model...")
+        self.model.generate("This is a warm-up prompt.")