symbolicai 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

symai/backend/engines/neurosymbolic/engine_openai_gptX_reasoning.py

@@ -26,17 +26,17 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
         self.config = deepcopy(SYMAI_CONFIG)
         # In case we use EngineRepository.register to inject the api_key and model => dynamically change the engine at runtime
         if api_key is not None and model is not None:
-            self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] = api_key
-            self.config['NEUROSYMBOLIC_ENGINE_MODEL']   = model
-        if self.id() != 'neurosymbolic':
-            return # do not initialize if not neurosymbolic; avoids conflict with llama.cpp check in EngineRepository.register_from_package
-        openai.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
-        self.model = self.config['NEUROSYMBOLIC_ENGINE_MODEL']
+            self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] = api_key
+            self.config["NEUROSYMBOLIC_ENGINE_MODEL"] = model
+        if self.id() != "neurosymbolic":
+            return  # do not initialize if not neurosymbolic; avoids conflict with llama.cpp check in EngineRepository.register_from_package
+        openai.api_key = self.config["NEUROSYMBOLIC_ENGINE_API_KEY"]
+        self.model = self.config["NEUROSYMBOLIC_ENGINE_MODEL"]
         self.name = self.__class__.__name__
         try:
             self.tokenizer = tiktoken.encoding_for_model(self.model)
         except Exception:
-            self.tokenizer = tiktoken.get_encoding('o200k_base')
+            self.tokenizer = tiktoken.get_encoding("o200k_base")
         self.max_context_tokens = self.api_max_context_tokens()
         self.max_response_tokens = self.api_max_response_tokens()
         self.seed = None
@@ -44,47 +44,53 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
         try:
             self.client = openai.Client(api_key=openai.api_key)
         except Exception as e:
-            UserMessage(f'Failed to initialize OpenAI client. Please check your OpenAI library version. Caused by: {e}', raise_with=ValueError)
+            UserMessage(
+                f"Failed to initialize OpenAI client. Please check your OpenAI library version. Caused by: {e}",
+                raise_with=ValueError,
+            )
 
     def id(self) -> str:
-        if self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') and \
-           (self.config.get('NEUROSYMBOLIC_ENGINE_MODEL').startswith('o1') or \
-            self.config.get('NEUROSYMBOLIC_ENGINE_MODEL').startswith('o3') or \
-            self.config.get('NEUROSYMBOLIC_ENGINE_MODEL').startswith('o4') or \
-            self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') == 'gpt-5' or \
-            self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') == 'gpt-5-mini' or \
-            self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') == 'gpt-5-nano'):
-                return 'neurosymbolic'
-        return super().id() # default to unregistered
+        if self.config.get("NEUROSYMBOLIC_ENGINE_MODEL") and (
+            self.config.get("NEUROSYMBOLIC_ENGINE_MODEL").startswith("o1")
+            or self.config.get("NEUROSYMBOLIC_ENGINE_MODEL").startswith("o3")
+            or self.config.get("NEUROSYMBOLIC_ENGINE_MODEL").startswith("o4")
+            or self.config.get("NEUROSYMBOLIC_ENGINE_MODEL") == "gpt-5"
+            or self.config.get("NEUROSYMBOLIC_ENGINE_MODEL") == "gpt-5.1"
+            or self.config.get("NEUROSYMBOLIC_ENGINE_MODEL") == "gpt-5-mini"
+            or self.config.get("NEUROSYMBOLIC_ENGINE_MODEL") == "gpt-5-nano"
+        ):
+            return "neurosymbolic"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'NEUROSYMBOLIC_ENGINE_API_KEY' in kwargs:
-            openai.api_key = kwargs['NEUROSYMBOLIC_ENGINE_API_KEY']
-        if 'NEUROSYMBOLIC_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['NEUROSYMBOLIC_ENGINE_MODEL']
-        if 'seed' in kwargs:
-            self.seed = kwargs['seed']
+        if "NEUROSYMBOLIC_ENGINE_API_KEY" in kwargs:
+            openai.api_key = kwargs["NEUROSYMBOLIC_ENGINE_API_KEY"]
+        if "NEUROSYMBOLIC_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["NEUROSYMBOLIC_ENGINE_MODEL"]
+        if "seed" in kwargs:
+            self.seed = kwargs["seed"]
 
     def compute_required_tokens(self, messages):
         """Return the number of tokens used by a list of messages."""
 
         if self.model in {
-            'o1',
-            'o3',
-            'o3-mini',
-            'o4-mini',
-            'gpt-5',
-            'gpt-5-mini',
-            'gpt-5-nano',
-            }:
+            "o1",
+            "o3",
+            "o3-mini",
+            "o4-mini",
+            "gpt-5",
+            "gpt-5.1",
+            "gpt-5-mini",
+            "gpt-5-nano",
+        }:
             tokens_per_message = 3
             tokens_per_name = 1
         else:
             UserMessage(
                 f"'num_tokens_from_messages()' is not implemented for model {self.model}. "
                 "See https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken for information on how messages are converted to tokens.",
-                raise_with=NotImplementedError
+                raise_with=NotImplementedError,
             )
 
         num_tokens = 0
@@ -95,12 +101,14 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
                     num_tokens += len(self.tokenizer.encode(value, disallowed_special=()))
                 else:
                     for v in value:
-                        if v['type'] == 'text':
-                            num_tokens += len(self.tokenizer.encode(v['text'], disallowed_special=()))
+                        if v["type"] == "text":
+                            num_tokens += len(
+                                self.tokenizer.encode(v["text"], disallowed_special=())
+                            )
                 if key == "name":
                     num_tokens += tokens_per_name
         num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
-        return num_tokens - 1 # don't know where that extra 1 comes from
+        return num_tokens - 1  # don't know where that extra 1 comes from
 
     def compute_remaining_tokens(self, prompts: list) -> int:
         val = self.compute_required_tokens(prompts)
@@ -108,33 +116,40 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
 
     def _handle_image_content(self, content: str) -> list:
         """Handle image content by processing vision patterns and returning image file data."""
+
         def _extract_pattern(text):
-            pattern = r'<<vision:(.*?):>>'
+            pattern = r"<<vision:(.*?):>>"
             return re.findall(pattern, text)
 
         image_files = []
         # pre-process prompt if contains image url
-        if (self.model == 'o1' or \
-            self.model == 'gpt-5' or \
-            self.model == 'gpt-5-mini' or \
-            self.model == 'gpt-5-nano') and '<<vision:' in content:
+        if (
+            self.model == "o1"
+            or self.model == "gpt-5"
+            or self.model == "gpt-5.1"
+            or self.model == "gpt-5-mini"
+            or self.model == "gpt-5-nano"
+        ) and "<<vision:" in content:
             parts = _extract_pattern(content)
             for p in parts:
                 img_ = p.strip()
-                if img_.startswith('http') or img_.startswith('data:image'):
+                if img_.startswith("http") or img_.startswith("data:image"):
                     image_files.append(img_)
                 else:
                     max_frames_spacing = 50
                     max_used_frames = 10
-                    if img_.startswith('frames:'):
-                        img_ = img_.replace('frames:', '')
-                        max_used_frames, img_ = img_.split(':')
+                    if img_.startswith("frames:"):
+                        img_ = img_.replace("frames:", "")
+                        max_used_frames, img_ = img_.split(":")
                         max_used_frames = int(max_used_frames)
                         if max_used_frames < 1 or max_used_frames > max_frames_spacing:
-                            UserMessage(f"Invalid max_used_frames value: {max_used_frames}. Expected value between 1 and {max_frames_spacing}", raise_with=ValueError)
+                            UserMessage(
+                                f"Invalid max_used_frames value: {max_used_frames}. Expected value between 1 and {max_frames_spacing}",
+                                raise_with=ValueError,
+                            )
                     buffer, ext = encode_media_frames(img_)
                     if len(buffer) > 1:
-                        step = len(buffer) // max_frames_spacing # max frames spacing
+                        step = len(buffer) // max_frames_spacing  # max frames spacing
                         frames = []
                         indices = list(range(0, len(buffer), step))[:max_used_frames]
                         for i in indices:
@@ -143,22 +158,22 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
                     elif len(buffer) == 1:
                         image_files.append(f"data:image/{ext};base64,{buffer[0]}")
                     else:
-                        UserMessage('No frames found or error in encoding frames')
+                        UserMessage("No frames found or error in encoding frames")
         return image_files
 
     def _remove_vision_pattern(self, text: str) -> str:
         """Remove vision patterns from text."""
-        pattern = r'<<vision:(.*?):>>'
-        return re.sub(pattern, '', text)
+        pattern = r"<<vision:(.*?):>>"
+        return re.sub(pattern, "", text)
 
     def _slice_tokens(self, tokens, new_len, truncation_type):
         """Slice tokens based on truncation type."""
         new_len = max(100, new_len)  # Ensure minimum token length
-        return tokens[-new_len:] if truncation_type == 'head' else tokens[:new_len]  # else 'tail'
+        return tokens[-new_len:] if truncation_type == "head" else tokens[:new_len]  # else 'tail'
 
     def _validate_truncation_prompts(self, prompts: list[dict]) -> bool:
         """Validate prompt structure before truncation."""
-        if len(prompts) != 2 and all(prompt['role'] in ['developer', 'user'] for prompt in prompts):
+        if len(prompts) != 2 and all(prompt["role"] in ["developer", "user"] for prompt in prompts):
             # Only support developer and user prompts
             UserMessage(
                 f"Token truncation currently supports only two messages, from 'user' and 'developer' (got {len(prompts)}). Returning original prompts."
@@ -172,15 +187,15 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
     ) -> tuple[list[int], bool]:
         """Collect user tokens and detect unsupported content."""
         user_tokens: list[int] = []
-        user_content = user_prompt['content']
+        user_content = user_prompt["content"]
         if isinstance(user_content, str):
             user_tokens.extend(Symbol(user_content).tokens)
             return user_tokens, False
         if isinstance(user_content, list):
             for content_item in user_content:
                 if isinstance(content_item, dict):
-                    if content_item.get('type') == 'text':
-                        user_tokens.extend(Symbol(content_item['text']).tokens)
+                    if content_item.get("type") == "text":
+                        user_tokens.extend(Symbol(content_item["text"]).tokens)
                     else:
                         return user_tokens, True
                 else:
@@ -209,19 +224,27 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
             new_user_len = max_prompt_tokens - system_token_count
             new_user_tokens = self._slice_tokens(user_tokens, new_user_len, truncation_type)
             return [
-                {'role': 'developer', 'content': self.tokenizer.decode(system_tokens)},
-                {'role': 'user', 'content': [{'type': 'text', 'text': self.tokenizer.decode(new_user_tokens)}]},
+                {"role": "developer", "content": self.tokenizer.decode(system_tokens)},
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": self.tokenizer.decode(new_user_tokens)}],
+                },
             ]
         if system_token_count > half_limit and user_token_count <= half_limit:
             new_system_len = max_prompt_tokens - user_token_count
             new_system_tokens = self._slice_tokens(system_tokens, new_system_len, truncation_type)
             return [
-                {'role': 'developer', 'content': self.tokenizer.decode(new_system_tokens)},
-                {'role': 'user', 'content': [{'type': 'text', 'text': self.tokenizer.decode(user_tokens)}]},
+                {"role": "developer", "content": self.tokenizer.decode(new_system_tokens)},
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": self.tokenizer.decode(user_tokens)}],
+                },
             ]
         return None
 
-    def truncate(self, prompts: list[dict], truncation_percentage: float | None, truncation_type: str) -> list[dict]:
+    def truncate(
+        self, prompts: list[dict], truncation_percentage: float | None, truncation_type: str
+    ) -> list[dict]:
         """Main truncation method"""
         if not self._validate_truncation_prompts(prompts):
             return prompts
@@ -234,7 +257,7 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
         user_prompt = prompts[1]
 
         # Get token counts
-        system_tokens = Symbol(system_prompt['content']).tokens
+        system_tokens = Symbol(system_prompt["content"]).tokens
         user_tokens = []
 
         user_tokens, should_return_original = self._collect_user_tokens(user_prompt)
@@ -257,7 +280,7 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
         UserMessage(
             f"Executing {truncation_type} truncation to fit within {max_prompt_tokens} tokens. "
             f"Combined prompts ({total_tokens} tokens) exceed maximum allowed tokens "
-            f"of {max_prompt_tokens} ({truncation_percentage*100:.1f}% of context). "
+            f"of {max_prompt_tokens} ({truncation_percentage * 100:.1f}% of context). "
             f"You can control this behavior by setting 'truncation_percentage' (current: {truncation_percentage:.2f}) "
             f"and 'truncation_type' (current: '{truncation_type}') parameters. "
             f"Set 'truncation_percentage=1.0' to deactivate truncation (will fail if exceeding context window). "
@@ -289,39 +312,49 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
         new_user_tokens = self._slice_tokens(user_tokens, new_user_len, truncation_type)
 
         return [
-            {'role': 'developer', 'content': self.tokenizer.decode(new_system_tokens)},
-            {'role': 'user', 'content': [{'type': 'text', 'text': self.tokenizer.decode(new_user_tokens)}]}
+            {"role": "developer", "content": self.tokenizer.decode(new_system_tokens)},
+            {
+                "role": "user",
+                "content": [{"type": "text", "text": self.tokenizer.decode(new_user_tokens)}],
+            },
         ]
 
     def forward(self, argument):
         kwargs = argument.kwargs
-        truncation_percentage = kwargs.get('truncation_percentage', argument.prop.truncation_percentage)
-        truncation_type = kwargs.get('truncation_type', argument.prop.truncation_type)
-        messages = self.truncate(argument.prop.prepared_input, truncation_percentage, truncation_type)
+        truncation_percentage = kwargs.get(
+            "truncation_percentage", argument.prop.truncation_percentage
+        )
+        truncation_type = kwargs.get("truncation_type", argument.prop.truncation_type)
+        messages = self.truncate(
+            argument.prop.prepared_input, truncation_percentage, truncation_type
+        )
         payload = self._prepare_request_payload(messages, argument)
-        except_remedy = kwargs.get('except_remedy')
+        except_remedy = kwargs.get("except_remedy")
 
         try:
             res = self.client.chat.completions.create(**payload)
 
         except Exception as e:
-            if openai.api_key is None or openai.api_key == '':
-                msg = 'OpenAI API key is not set. Please set it in the config file or pass it as an argument to the command method.'
+            if openai.api_key is None or openai.api_key == "":
+                msg = "OpenAI API key is not set. Please set it in the config file or pass it as an argument to the command method."
                 UserMessage(msg)
-                if self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] is None or self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] == '':
+                if (
+                    self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] is None
+                    or self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] == ""
+                ):
                     UserMessage(msg, raise_with=ValueError)
-                openai.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
+                openai.api_key = self.config["NEUROSYMBOLIC_ENGINE_API_KEY"]
 
             callback = self.client.chat.completions.create
-            kwargs['model'] = kwargs.get('model', self.model)
+            kwargs["model"] = kwargs.get("model", self.model)
 
             if except_remedy is not None:
                 res = except_remedy(self, e, callback, argument)
             else:
-                UserMessage(f'Error during generation. Caused by: {e}', raise_with=ValueError)
+                UserMessage(f"Error during generation. Caused by: {e}", raise_with=ValueError)
 
-        metadata = {'raw_output': res}
-        if payload.get('tools'):
+        metadata = {"raw_output": res}
+        if payload.get("tools"):
             metadata = self._process_function_calls(res, metadata)
         output = [r.message.content for r in res.choices]
 
@@ -329,12 +362,15 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
 
     def _prepare_raw_input(self, argument):
         if not argument.prop.processed_input:
-            UserMessage('Need to provide a prompt instruction to the engine if raw_input is enabled.', raise_with=ValueError)
+            UserMessage(
+                "Need to provide a prompt instruction to the engine if raw_input is enabled.",
+                raise_with=ValueError,
+            )
         value = argument.prop.processed_input
         # convert to dict if not already
         if not isinstance(value, list):
             if not isinstance(value, dict):
-                value = {'role': 'user', 'content': str(value)}
+                value = {"role": "user", "content": str(value)}
             value = [value]
         return value
 
@@ -344,21 +380,23 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
             return (
                 "<META_INSTRUCTION/>\n"
                 "You do not output anything else, like verbose preambles or post explanation, such as "
-                "\"Sure, let me...\", \"Hope that was helpful...\", \"Yes, I can help you with that...\", etc. "
+                '"Sure, let me...", "Hope that was helpful...", "Yes, I can help you with that...", etc. '
                 "Consider well formatted output, e.g. for sentences use punctuation, spaces etc. or for code use "
                 "indentation, etc. Never add meta instructions information to your output!\n\n"
             )
-        return ''
+        return ""
 
     def _response_format_section(self, argument) -> str:
         """Return response format instructions if provided."""
         if not argument.prop.response_format:
-            return ''
+            return ""
         response_format = argument.prop.response_format
-        assert response_format.get('type') is not None, 'Expected format `{ "type": "json_object" }`! See https://platform.openai.com/docs/api-reference/chat/create#chat-create-response_format'
+        assert response_format.get("type") is not None, (
+            'Expected format `{ "type": "json_object" }`! See https://platform.openai.com/docs/api-reference/chat/create#chat-create-response_format'
+        )
         if response_format["type"] == "json_object":
-            return '<RESPONSE_FORMAT/>\nYou are a helpful assistant designed to output JSON.\n\n'
-        return ''
+            return "<RESPONSE_FORMAT/>\nYou are a helpful assistant designed to output JSON.\n\n"
+        return ""
 
     def _context_sections(self, argument) -> list[str]:
         """Return static and dynamic context sections."""
@@ -374,20 +412,20 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
         """Return additional payload context if any."""
         if argument.prop.payload:
             return f"<ADDITIONAL CONTEXT/>\n{argument.prop.payload!s}\n\n"
-        return ''
+        return ""
 
     def _examples_section(self, argument) -> str:
         """Return examples section if provided."""
         examples: list[str] = argument.prop.examples
         if examples and len(examples) > 0:
             return f"<EXAMPLES/>\n{examples!s}\n\n"
-        return ''
+        return ""
 
     def _instruction_section(self, argument, image_files: list[str]) -> str:
         """Return instruction section, removing vision patterns when needed."""
         prompt = argument.prop.prompt
         if prompt is None or len(prompt) == 0:
-            return ''
+            return ""
         value = str(prompt)
         if len(image_files) > 0:
             value = self._remove_vision_pattern(value)
@@ -396,7 +434,7 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
     def _build_developer_prompt(self, argument, image_files: list[str]) -> str:
         """Assemble developer prompt content."""
         developer = self._non_verbose_section(argument)
-        developer = f'{developer}\n' if developer else ''
+        developer = f"{developer}\n" if developer else ""
 
         parts = [
             self._response_format_section(argument),
@@ -405,12 +443,12 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
             self._examples_section(argument),
             self._instruction_section(argument, image_files),
         ]
-        developer += ''.join(part for part in parts if part)
+        developer += "".join(part for part in parts if part)
 
         if argument.prop.template_suffix:
             developer += (
-                f' You will only generate content for the placeholder `{argument.prop.template_suffix!s}` '
-                'following the instructions and the provided context information.\n\n'
+                f" You will only generate content for the placeholder `{argument.prop.template_suffix!s}` "
+                "following the instructions and the provided context information.\n\n"
             )
         return developer
 
@@ -424,20 +462,21 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
     def _construct_user_prompt(self, user_text: str, image_files: list[str]):
         """Construct user prompt payload."""
         if self.model in {
-                'o1',
-                'o3',
-                'o3-mini',
-                'o4-mini',
-                'gpt-5',
-                'gpt-5-mini',
-                'gpt-5-nano',
-            }:
-            images = [{'type': 'image_url', 'image_url': {'url': file}} for file in image_files]
+            "o1",
+            "o3",
+            "o3-mini",
+            "o4-mini",
+            "gpt-5",
+            "gpt-5.1",
+            "gpt-5-mini",
+            "gpt-5-nano",
+        }:
+            images = [{"type": "image_url", "image_url": {"url": file}} for file in image_files]
             user_prompt = {
                 "role": "user",
                 "content": [
                     *images,
-                    {'type': 'text', 'text': user_text},
+                    {"type": "text", "text": user_text},
                 ],
             }
             return user_prompt, images
@@ -454,29 +493,31 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
     ):
         """Apply self-prompting when requested."""
         instance = argument.prop.instance
-        if not (instance._kwargs.get('self_prompt', False) or argument.prop.self_prompt):
+        if not (instance._kwargs.get("self_prompt", False) or argument.prop.self_prompt):
             return user_prompt, developer
 
         self_prompter = SelfPrompt()
-        res = self_prompter({'user': user_text, 'developer': developer})
+        res = self_prompter({"user": user_text, "developer": developer})
         if res is None:
             UserMessage("Self-prompting failed!", raise_with=ValueError)
 
         if len(image_files) > 0:
-            image_content = images if images is not None else [
-                {'type': 'image_url', 'image_url': {'url': file}} for file in image_files
-            ]
+            image_content = (
+                images
+                if images is not None
+                else [{"type": "image_url", "image_url": {"url": file}} for file in image_files]
+            )
             user_prompt = {
                 "role": "user",
                 "content": [
                     *image_content,
-                    {'type': 'text', 'text': res['user']},
+                    {"type": "text", "text": res["user"]},
                 ],
             }
         else:
-            user_prompt = {"role": "user", "content": res['user']}
+            user_prompt = {"role": "user", "content": res["user"]}
 
-        return user_prompt, res['developer']
+        return user_prompt, res["developer"]
 
     def prepare(self, argument):
         if argument.prop.raw_input:
@@ -498,32 +539,34 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
         )
 
         argument.prop.prepared_input = [
-            { "role": "developer", "content": developer },
+            {"role": "developer", "content": developer},
             user_prompt,
         ]
 
     def _process_function_calls(self, res, metadata):
         hit = False
         if (
-            hasattr(res, 'choices')
+            hasattr(res, "choices")
             and res.choices
-            and hasattr(res.choices[0], 'message')
+            and hasattr(res.choices[0], "message")
             and res.choices[0].message
-            and hasattr(res.choices[0].message, 'tool_calls')
+            and hasattr(res.choices[0].message, "tool_calls")
             and res.choices[0].message.tool_calls
         ):
             for tool_call in res.choices[0].message.tool_calls:
                 if hit:
-                    UserMessage("Multiple function calls detected in the response but only the first one will be processed.")
+                    UserMessage(
+                        "Multiple function calls detected in the response but only the first one will be processed."
+                    )
                     break
-                if hasattr(tool_call, 'function') and tool_call.function:
+                if hasattr(tool_call, "function") and tool_call.function:
                     try:
                         args_dict = json.loads(tool_call.function.arguments)
                     except json.JSONDecodeError:
                         args_dict = {}
-                    metadata['function_call'] = {
-                        'name': tool_call.function.name,
-                        'arguments': args_dict
+                    metadata["function_call"] = {
+                        "name": tool_call.function.name,
+                        "arguments": args_dict,
                     }
                     hit = True
         return metadata
@@ -532,8 +575,8 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
         """Prepares the request payload from the argument."""
         kwargs = argument.kwargs
 
-        max_tokens = kwargs.get('max_tokens', None)
-        max_completion_tokens = kwargs.get('max_completion_tokens', None)
+        max_tokens = kwargs.get("max_tokens", None)
+        max_completion_tokens = kwargs.get("max_completion_tokens", None)
         remaining_tokens = self.compute_remaining_tokens(messages)
 
         if max_tokens is not None:
@@ -547,34 +590,34 @@ class GPTXReasoningEngine(Engine, OpenAIMixin):
                     f"Provided 'max_tokens' ({max_tokens}) exceeds max response tokens ({self.max_response_tokens}). "
                     f"Truncating to {remaining_tokens} to avoid API failure."
                 )
-                kwargs['max_completion_tokens'] = remaining_tokens
+                kwargs["max_completion_tokens"] = remaining_tokens
             else:
-                kwargs['max_completion_tokens'] = max_tokens
-            del kwargs['max_tokens']
+                kwargs["max_completion_tokens"] = max_tokens
+            del kwargs["max_tokens"]
 
         if max_completion_tokens is not None and max_completion_tokens > self.max_response_tokens:
             UserMessage(
                 f"Provided 'max_completion_tokens' ({max_completion_tokens}) exceeds max response tokens ({self.max_response_tokens}). "
                 f"Truncating to {remaining_tokens} to avoid API failure."
             )
-            kwargs['max_completion_tokens'] = remaining_tokens
+            kwargs["max_completion_tokens"] = remaining_tokens
 
         payload = {
             "messages": messages,
-            "model": kwargs.get('model', self.model),
-            "seed": kwargs.get('seed', self.seed),
-            "reasoning_effort": kwargs.get('reasoning_effort', 'medium'),
-            "max_completion_tokens": kwargs.get('max_completion_tokens'),
-            "stop": kwargs.get('stop', ''),
-            "temperature": kwargs.get('temperature', 1),
-            "frequency_penalty": kwargs.get('frequency_penalty', 0),
-            "presence_penalty": kwargs.get('presence_penalty', 0),
-            "top_p": kwargs.get('top_p', 1),
-            "n": kwargs.get('n', 1),
-            "logit_bias": kwargs.get('logit_bias'),
-            "tools": kwargs.get('tools'),
-            "tool_choice": kwargs.get('tool_choice'),
-            "response_format": kwargs.get('response_format'),
+            "model": kwargs.get("model", self.model),
+            "seed": kwargs.get("seed", self.seed),
+            "reasoning_effort": kwargs.get("reasoning_effort", "medium"),
+            "max_completion_tokens": kwargs.get("max_completion_tokens"),
+            "stop": kwargs.get("stop", ""),
+            "temperature": kwargs.get("temperature", 1),
+            "frequency_penalty": kwargs.get("frequency_penalty", 0),
+            "presence_penalty": kwargs.get("presence_penalty", 0),
+            "top_p": kwargs.get("top_p", 1),
+            "n": kwargs.get("n", 1),
+            "logit_bias": kwargs.get("logit_bias"),
+            "tools": kwargs.get("tools"),
+            "tool_choice": kwargs.get("tool_choice"),
+            "response_format": kwargs.get("response_format"),
         }
 
         if self.model == "o4-mini" or self.model == "o3":