janito 2.7.0__py3-none-any.whl → 2.8.0__py3-none-any.whl

janito/cli/main_cli.py

@@ -21,7 +21,6 @@ definition = [
             "help": "Disable path security: allow tool arguments to use any file/directory path (DANGEROUS)",
         },
     ),
-
     (
         ["--profile"],
         {
@@ -114,7 +113,7 @@ definition = [
             "help": "Set API key for the provider (requires -p PROVIDER)",
         },
     ),
-    (["--set"], {"metavar": "[PROVIDER_NAME.]KEY=VALUE", "help": "Set a config key"}),
+    (["--set"], {"metavar": "KEY=VALUE", "help": "Set a config key"}),
     (["-s", "--system"], {"metavar": "SYSTEM_PROMPT", "help": "Set a system prompt"}),
     (
         ["-S", "--show-system"],
@@ -141,22 +140,7 @@ definition = [
         },
     ),
     (
-        ["--web"],
-        {
-            "action": "store_true",
-            "default": False,
-            "help": "Enable the builtin lightweight web file viewer for terminal links (disabled by default)",
-        },
-    ),
-    (
-        ["---port"],
-        {
-            "type": int,
-            "default": 8088,
-            "help": "Port for the  server (default: 8088)",
-        },
-    ),
-    (["--effort"],
+        ["--effort"],
         {
             "choices": ["low", "medium", "high", "none"],
             "default": None,
@@ -184,11 +168,8 @@ MODIFIER_KEYS = [
     "profile",
     "system",
     "temperature",
-
     "verbose",
     "raw",
-    "web",
-    "_port",
     "verbose_api",
     "verbose_tools",
     "exec",
@@ -219,12 +200,13 @@ class JanitoCLI:
         self._set_all_arg_defaults()
         # Support reading prompt from stdin if no user_prompt is given
         import sys
+
         if not sys.stdin.isatty():
             stdin_input = sys.stdin.read().strip()
             if stdin_input:
                 if self.args.user_prompt and len(self.args.user_prompt) > 0:
                     # Prefix the prompt argument to the stdin input
-                    combined = ' '.join(self.args.user_prompt) + ' ' + stdin_input
+                    combined = " ".join(self.args.user_prompt) + " " + stdin_input
                     self.args.user_prompt = [combined]
                 else:
                     self.args.user_prompt = [stdin_input]
@@ -295,7 +277,9 @@ class JanitoCLI:
             handle_getter(self.args)
             return
         # If running in single shot mode and --profile is not provided, default to 'developer' profile
-        if get_prompt_mode(self.args) == "single_shot" and not getattr(self.args, "profile", None):
+        if get_prompt_mode(self.args) == "single_shot" and not getattr(
+            self.args, "profile", None
+        ):
             self.args.profile = "developer"
         provider = self._get_provider_or_default()
         if provider is None:
@@ -316,14 +300,14 @@ class JanitoCLI:
         if run_mode == RunMode.RUN:
             self._maybe_print_verbose_run_mode()
             # DEBUG: Print exec_enabled propagation at main_cli
-            
+
             handle_runner(
                 self.args,
                 provider,
                 llm_driver_config,
                 agent_role,
                 verbose_tools=self.args.verbose_tools,
-                            )
+            )
         elif run_mode == RunMode.GET:
             handle_getter(self.args)
 

janito/cli/prompt_core.py

@@ -8,7 +8,12 @@ from janito.performance_collector import PerformanceCollector
 from rich.status import Status
 from rich.console import Console
 from typing import Any, Optional, Callable
-from janito.driver_events import RequestStarted, RequestFinished, RequestStatus, RateLimitRetry
+from janito.driver_events import (
+    RequestStarted,
+    RequestFinished,
+    RequestStatus,
+    RateLimitRetry,
+)
 from janito.tools.tool_events import ToolCallError
 import threading
 from janito.cli.verbose_output import print_verbose_header
@@ -56,7 +61,10 @@ class PromptHandler:
         if isinstance(inner_event, RequestFinished):
             if getattr(inner_event, "status", None) == "error":
                 return self._handle_request_finished_error(inner_event, status)
-            if getattr(inner_event, "status", None) in (RequestStatus.EMPTY_RESPONSE, RequestStatus.TIMEOUT):
+            if getattr(inner_event, "status", None) in (
+                RequestStatus.EMPTY_RESPONSE,
+                RequestStatus.TIMEOUT,
+            ):
                 return self._handle_empty_or_timeout(inner_event, status)
             status.update("[bold green]Received response![bold green]")
             return "break"
@@ -78,7 +86,9 @@ class PromptHandler:
         return None
 
     def _handle_rate_limit_retry(self, inner_event, status):
-        status.update(f"[yellow]Rate limited. Waiting {inner_event.retry_delay:.0f}s before retry (attempt {inner_event.attempt}).[yellow]")
+        status.update(
+            f"[yellow]Rate limited. Waiting {inner_event.retry_delay:.0f}s before retry (attempt {inner_event.attempt}).[yellow]"
+        )
         return None
 
     def _handle_request_finished_error(self, inner_event, status):
@@ -89,9 +99,7 @@ class PromptHandler:
             "Status 429" in error_msg
             and "Service tier capacity exceeded for this model" in error_msg
         ):
-            status.update(
-                "[yellow]Service tier capacity exceeded, retrying...[yellow]"
-            )
+            status.update("[yellow]Service tier capacity exceeded, retrying...[yellow]")
             return "break"
         status.update(f"[bold red]Error: {error_msg}[bold red]")
         self.console.print(f"[red]Error: {error_msg}[red]")
@@ -99,18 +107,12 @@ class PromptHandler:
 
     def _handle_tool_call_error(self, inner_event, status):
         error_msg = (
-            inner_event.error
-            if hasattr(inner_event, "error")
-            else "Unknown tool error"
+            inner_event.error if hasattr(inner_event, "error") else "Unknown tool error"
         )
         tool_name = (
-            inner_event.tool_name
-            if hasattr(inner_event, "tool_name")
-            else "unknown"
-        )
-        status.update(
-            f"[bold red]Tool Error in '{tool_name}': {error_msg}[bold red]"
+            inner_event.tool_name if hasattr(inner_event, "tool_name") else "unknown"
         )
+        status.update(f"[bold red]Tool Error in '{tool_name}': {error_msg}[bold red]")
         self.console.print(f"[red]Tool Error in '{tool_name}': {error_msg}[red]")
         return "break"
 
@@ -118,9 +120,7 @@ class PromptHandler:
         details = getattr(inner_event, "details", None) or {}
         block_reason = details.get("block_reason")
         block_msg = details.get("block_reason_message")
-        msg = details.get(
-            "message", "LLM returned an empty or incomplete response."
-        )
+        msg = details.get("message", "LLM returned an empty or incomplete response.")
         driver_name = getattr(inner_event, "driver_name", "unknown driver")
         if block_reason or block_msg:
             status.update(
@@ -221,6 +221,7 @@ class PromptHandler:
             self.console.print("[red]Interrupted by the user.[/red]")
             try:
                 from janito.driver_events import RequestFinished, RequestStatus
+
                 # Record a synthetic "cancelled" final event so that downstream
                 # handlers (e.g. single_shot_mode.handler._post_prompt_actions)
                 # can reliably detect that the prompt was interrupted by the

janito/cli/prompt_setup.py

@@ -4,6 +4,7 @@ both single–shot and chat modes can reuse.  Having one central place avoids th
 code duplication that previously existed in `chat_mode.session.ChatSession` and
 `single_shot_mode.handler.PromptHandler`.
 """
+
 from __future__ import annotations
 
 from janito.agent.setup_agent import create_configured_agent
@@ -21,7 +22,6 @@ def setup_agent_and_prompt_handler(
     role: Optional[str] = None,
     verbose_tools: bool = False,
     verbose_agent: bool = False,
-    
     allowed_permissions: Optional[list[str]] = None,
     profile: Optional[str] = None,
     profile_system_prompt: Optional[str] = None,
@@ -34,16 +34,19 @@ def setup_agent_and_prompt_handler(
     across *single-shot* and *chat* modes – both of which need an agent plus a
     prompt handler that points to that agent.
     """
+    no_tools_mode = False
+    if hasattr(args, 'no_tools_mode'):
+        no_tools_mode = getattr(args, 'no_tools_mode', False)
     agent = create_configured_agent(
         provider_instance=provider_instance,
         llm_driver_config=llm_driver_config,
         role=role,
         verbose_tools=verbose_tools,
         verbose_agent=verbose_agent,
-        
         allowed_permissions=allowed_permissions,
         profile=profile,
         profile_system_prompt=profile_system_prompt,
+        no_tools_mode=no_tools_mode,
     )
 
     prompt_handler = GenericPromptHandler(
@@ -53,4 +56,4 @@ def setup_agent_and_prompt_handler(
     )
     prompt_handler.agent = agent
 
-    return agent, prompt_handler
+    return agent, prompt_handler

janito/cli/rich_terminal_reporter.py

@@ -12,6 +12,7 @@ from janito.llm import message_parts
 
 import sys
 
+
 class RichTerminalReporter(EventHandlerBase):
     """
     Handles UI rendering for janito events using Rich.
@@ -31,6 +32,7 @@ class RichTerminalReporter(EventHandlerBase):
         import janito.report_events as report_events
 
         import janito.tools.tool_events as tool_events
+
         super().__init__(driver_events, report_events, tool_events)
         self._waiting_printed = False
 
@@ -53,7 +55,9 @@ class RichTerminalReporter(EventHandlerBase):
             model = getattr(event, "model_name", None)
         if not model:
             model = "?"
-        self.console.print(f"[bold cyan]Waiting for {provider} (model: {model})...[/bold cyan]", end="")
+        self.console.print(
+            f"[bold cyan]Waiting for {provider} (model: {model})...[/bold cyan]", end=""
+        )
 
     def on_ResponseReceived(self, event):
         parts = event.parts if hasattr(event, "parts") else None
@@ -70,7 +74,7 @@ class RichTerminalReporter(EventHandlerBase):
         """
         Clears the entire current line in the terminal and returns the cursor to column 1.
         """
-        sys.stdout.write('\033[2K\r')
+        sys.stdout.write("\033[2K\r")
         sys.stdout.flush()
 
     def on_RequestFinished(self, event):
@@ -118,9 +122,15 @@ class RichTerminalReporter(EventHandlerBase):
         action = getattr(event, "action", None)
         tool = getattr(event, "tool", None)
         context = getattr(event, "context", None)
-        if subtype == ReportSubtype.ERROR and msg and "[SECURITY] Path access denied" in msg:
+        if (
+            subtype == ReportSubtype.ERROR
+            and msg
+            and "[SECURITY] Path access denied" in msg
+        ):
             # Highlight security errors with a distinct style
-            self.console.print(Panel(f"{msg}", title="[red]SECURITY VIOLATION[/red]", style="bold red"))
+            self.console.print(
+                Panel(f"{msg}", title="[red]SECURITY VIOLATION[/red]", style="bold red")
+            )
             self.console.file.flush()
             return
 
@@ -135,7 +145,11 @@ class RichTerminalReporter(EventHandlerBase):
                 getattr(ReportAction, "WRITE", None),
                 getattr(ReportAction, "DELETE", None),
             )
-            style = "orange1" if getattr(event, "action", None) in modification_actions else "cyan"
+            style = (
+                "orange1"
+                if getattr(event, "action", None) in modification_actions
+                else "cyan"
+            )
             self.console.print(Text(msg, style=style), end="")
             self.console.file.flush()
         elif subtype in (

janito/cli/single_shot_mode/handler.py

@@ -11,12 +11,19 @@ import time
 
 
 class PromptHandler:
-    def __init__(self, args, provider_instance, llm_driver_config, role=None,  allowed_permissions=None):
+    def __init__(
+        self,
+        args,
+        provider_instance,
+        llm_driver_config,
+        role=None,
+        allowed_permissions=None,
+    ):
         self.args = args
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
         self.role = role
-                # Instantiate agent together with prompt handler using the shared helper
+        # Instantiate agent together with prompt handler using the shared helper
         self.agent, self.generic_handler = setup_agent_and_prompt_handler(
             args=args,
             provider_instance=provider_instance,
@@ -24,7 +31,6 @@ class PromptHandler:
             role=role,
             verbose_tools=getattr(args, "verbose_tools", False),
             verbose_agent=getattr(args, "verbose_agent", False),
-            
             allowed_permissions=allowed_permissions,
             profile=getattr(args, "profile", None),
         )
@@ -43,6 +49,7 @@ class PromptHandler:
                 "[yellow]Warning: Some characters in your input were not valid UTF-8 and have been replaced.[/yellow]"
             )
         import time
+
         try:
             start_time = time.time()
             self.generic_handler.handle_prompt(
@@ -67,13 +74,15 @@ class PromptHandler:
         import sys
         from janito.formatting_token import print_token_message_summary
         from janito.perf_singleton import performance_collector
+
         usage = performance_collector.get_last_request_usage()
         # If running in stdin mode, do not print token usage
         if sys.stdin.isatty():
-            print_token_message_summary(shared_console, msg_count=1, usage=usage, elapsed=elapsed)
+            print_token_message_summary(
+                shared_console, msg_count=1, usage=usage, elapsed=elapsed
+            )
         self._cleanup_driver_and_console()
 
-
     def _cleanup_driver_and_console(self):
         if hasattr(self.agent, "join_driver"):
             if (

janito/cli/verbose_output.py

@@ -19,7 +19,11 @@ def print_verbose_header(agent, args):
         parts = [
             f"Janito {VERSION}",
             f"Provider: {agent.llm_provider.__class__.__name__}",
-            (f"Model: {agent.llm_provider.driver_config.extra.get('azure_deployment_name', agent.llm_provider.driver_config.model)}{role_part}" if agent.llm_provider.__class__.__name__ == 'AzureOpenAIProvider' else f"Model: {getattr(agent.llm_provider.driver_config, 'model', '-')}{role_part}"),
+            (
+                f"Model: {agent.llm_provider.driver_config.extra.get('azure_deployment_name', agent.llm_provider.driver_config.model)}{role_part}"
+                if agent.llm_provider.__class__.__name__ == "AzureOpenAIProvider"
+                else f"Model: {getattr(agent.llm_provider.driver_config, 'model', '-')}{role_part}"
+            ),
             f"Driver: {agent.llm_provider.__class__.__module__.split('.')[-2] if len(agent.llm_provider.__class__.__module__.split('.')) > 1 else agent.llm_provider.__class__.__name__}",
         ]
         if hasattr(args, "think") and args.think:

janito/config_manager.py

@@ -40,11 +40,15 @@ class ConfigManager:
             try:
                 from janito.tools.permissions_parse import parse_permissions_string
                 from janito.tools.permissions import set_global_allowed_permissions
+
                 perms = parse_permissions_string(perm_str)
                 set_global_allowed_permissions(perms)
             except Exception as e:
                 print(f"Warning: Failed to apply tool_permissions from config: {e}")
 
+        # Load disabled tools from config - skip during startup to avoid circular imports
+        # This will be handled by the CLI when needed
+
     def _load_file_config(self):
         if self.config_path.exists():
             with open(self.config_path, "r", encoding="utf-8") as f:

janito/drivers/azure_openai/driver.py

@@ -1,14 +1,6 @@
 from janito.drivers.openai.driver import OpenAIModelDriver
 
-# Safe import of AzureOpenAI SDK
-try:
-    from openai import AzureOpenAI
-
-    DRIVER_AVAILABLE = True
-    DRIVER_UNAVAILABLE_REASON = None
-except ImportError:
-    DRIVER_AVAILABLE = False
-    DRIVER_UNAVAILABLE_REASON = "Missing dependency: openai (pip install openai)"
+from openai import AzureOpenAI
 
 from janito.llm.driver_config import LLMDriverConfig
 
@@ -16,30 +8,22 @@ from janito.llm.driver_config import LLMDriverConfig
 class AzureOpenAIModelDriver(OpenAIModelDriver):
     def start(self, *args, **kwargs):
         # Ensure azure_deployment_name is set before starting
-        config = getattr(self, 'config', None)
+        config = getattr(self, "config", None)
         deployment_name = None
-        if config and hasattr(config, 'extra'):
-            deployment_name = config.extra.get('azure_deployment_name')
+        if config and hasattr(config, "extra"):
+            deployment_name = config.extra.get("azure_deployment_name")
         if not deployment_name:
-            raise RuntimeError("AzureOpenAIModelDriver requires 'azure_deployment_name' to be set in config.extra['azure_deployment_name'] before starting.")
+            raise RuntimeError(
+                "AzureOpenAIModelDriver requires 'azure_deployment_name' to be set in config.extra['azure_deployment_name'] before starting."
+            )
         # Call parent start if exists
-        if hasattr(super(), 'start'):
+        if hasattr(super(), "start"):
             return super().start(*args, **kwargs)
 
-    available = DRIVER_AVAILABLE
-    unavailable_reason = DRIVER_UNAVAILABLE_REASON
-
-    @classmethod
-    def is_available(cls):
-        return cls.available
-
     required_config = {"base_url"}  # Update key as used in your config logic
 
     def __init__(self, tools_adapter=None, provider_name=None):
-        if not self.available:
-            raise ImportError(
-                f"AzureOpenAIModelDriver unavailable: {self.unavailable_reason}"
-            )
+
         # Ensure proper parent initialization
         super().__init__(tools_adapter=tools_adapter, provider_name=provider_name)
         self.azure_endpoint = None
@@ -52,25 +36,35 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
         Also ensures tool schemas are included if tools_adapter is present.
         """
         api_kwargs = super()._prepare_api_kwargs(config, conversation)
-        deployment_name = config.extra.get("azure_deployment_name") if hasattr(config, "extra") else None
+        deployment_name = (
+            config.extra.get("azure_deployment_name")
+            if hasattr(config, "extra")
+            else None
+        )
         if deployment_name:
             api_kwargs["model"] = deployment_name
         # Patch: Ensure tools are included for Azure as for OpenAI
         if self.tools_adapter:
             try:
-                from janito.providers.openai.schema_generator import generate_tool_schemas
+                from janito.providers.openai.schema_generator import (
+                    generate_tool_schemas,
+                )
+
                 tool_classes = self.tools_adapter.get_tool_classes()
                 tool_schemas = generate_tool_schemas(tool_classes)
                 api_kwargs["tools"] = tool_schemas
             except Exception as e:
                 api_kwargs["tools"] = []
                 if hasattr(config, "verbose_api") and config.verbose_api:
-                    print(f"[AzureOpenAIModelDriver] Tool schema generation failed: {e}")
+                    print(
+                        f"[AzureOpenAIModelDriver] Tool schema generation failed: {e}"
+                    )
         return api_kwargs
 
     def _instantiate_openai_client(self, config):
         try:
             from openai import AzureOpenAI
+
             api_key_display = str(config.api_key)
             if api_key_display and len(api_key_display) > 8:
                 api_key_display = api_key_display[:4] + "..." + api_key_display[-4:]
@@ -83,8 +77,11 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
             client = AzureOpenAI(**client_kwargs)
             return client
         except Exception as e:
-            print(f"[ERROR] Exception during AzureOpenAI client instantiation: {e}", flush=True)
+            print(
+                f"[ERROR] Exception during AzureOpenAI client instantiation: {e}",
+                flush=True,
+            )
             import traceback
+
             print(traceback.format_exc(), flush=True)
             raise
-

janito/drivers/openai/driver.py

@@ -12,15 +12,7 @@ from janito.llm.driver_input import DriverInput
 from janito.driver_events import RequestFinished, RequestStatus, RateLimitRetry
 from janito.llm.message_parts import TextMessagePart, FunctionCallMessagePart
 
-# Safe import of openai SDK
-try:
-    import openai
-
-    DRIVER_AVAILABLE = True
-    DRIVER_UNAVAILABLE_REASON = None
-except ImportError:
-    DRIVER_AVAILABLE = False
-    DRIVER_UNAVAILABLE_REASON = "Missing dependency: openai (pip install openai)"
+import openai
 
 
 class OpenAIModelDriver(LLMDriver):
@@ -33,8 +25,6 @@ class OpenAIModelDriver(LLMDriver):
     """
     OpenAI LLM driver (threaded, queue-based, stateless). Uses input/output queues accessible via instance attributes.
     """
-    available = DRIVER_AVAILABLE
-    unavailable_reason = DRIVER_UNAVAILABLE_REASON
 
     def __init__(self, tools_adapter=None, provider_name=None):
         super().__init__(tools_adapter=tools_adapter, provider_name=provider_name)
@@ -84,13 +74,17 @@ class OpenAIModelDriver(LLMDriver):
                 api_kwargs[p] = v
         api_kwargs["messages"] = conversation
         api_kwargs["stream"] = False
+        if self.tools_adapter and self.tools_adapter.get_tool_classes():
+            api_kwargs["parallel_tool_calls"] = True
         return api_kwargs
 
     def _call_api(self, driver_input: DriverInput):
         """Call the OpenAI-compatible chat completion endpoint with retry and error handling."""
         cancel_event = getattr(driver_input, "cancel_event", None)
         config = driver_input.config
-        conversation = self.convert_history_to_api_messages(driver_input.conversation_history)
+        conversation = self.convert_history_to_api_messages(
+            driver_input.conversation_history
+        )
         request_id = getattr(config, "request_id", None)
         self._print_api_call_start(config)
         client = self._instantiate_openai_client(config)
@@ -108,14 +102,18 @@ class OpenAIModelDriver(LLMDriver):
                 self._handle_api_success(config, result, request_id)
                 return result
             except Exception as e:
-                if self._handle_api_exception(e, config, api_kwargs, attempt, max_retries, request_id):
+                if self._handle_api_exception(
+                    e, config, api_kwargs, attempt, max_retries, request_id
+                ):
                     attempt += 1
                     continue
                 raise
 
     def _print_api_call_start(self, config):
         if getattr(config, "verbose_api", False):
-            tool_adapter_name = type(self.tools_adapter).__name__ if self.tools_adapter else None
+            tool_adapter_name = (
+                type(self.tools_adapter).__name__ if self.tools_adapter else None
+            )
             tool_names = []
             if self.tools_adapter and hasattr(self.tools_adapter, "list_tools"):
                 try:
@@ -156,17 +154,21 @@ class OpenAIModelDriver(LLMDriver):
             print("[OpenAI] API RESPONSE:", flush=True)
             pretty.pprint(result)
 
-    def _handle_api_exception(self, e, config, api_kwargs, attempt, max_retries, request_id):
+    def _handle_api_exception(
+        self, e, config, api_kwargs, attempt, max_retries, request_id
+    ):
         status_code = getattr(e, "status_code", None)
         err_str = str(e)
         lower_err = err_str.lower()
         is_insufficient_quota = (
-            "insufficient_quota" in lower_err or "exceeded your current quota" in lower_err
+            "insufficient_quota" in lower_err
+            or "exceeded your current quota" in lower_err
         )
         is_rate_limit = (
-            (status_code == 429 or "error code: 429" in lower_err or "resource_exhausted" in lower_err)
-            and not is_insufficient_quota
-        )
+            status_code == 429
+            or "error code: 429" in lower_err
+            or "resource_exhausted" in lower_err
+        ) and not is_insufficient_quota
         if not is_rate_limit or attempt > max_retries:
             self._handle_fatal_exception(e, config, api_kwargs)
         retry_delay = self._extract_retry_delay_seconds(e)
@@ -189,7 +191,9 @@ class OpenAIModelDriver(LLMDriver):
             )
         start_wait = time.time()
         while time.time() - start_wait < retry_delay:
-            if self._check_cancel(getattr(config, "cancel_event", None), request_id, before_call=False):
+            if self._check_cancel(
+                getattr(config, "cancel_event", None), request_id, before_call=False
+            ):
                 return False
             time.sleep(0.1)
         return True
@@ -208,7 +212,9 @@ class OpenAIModelDriver(LLMDriver):
             else:
                 payload = str(exception)
             # Look for 'retryDelay': '41s' or similar
-            m = re.search(r"retryDelay['\"]?\s*[:=]\s*['\"]?(\d+(?:\.\d+)?)(s)?", payload)
+            m = re.search(
+                r"retryDelay['\"]?\s*[:=]\s*['\"]?(\d+(?:\.\d+)?)(s)?", payload
+            )
             if m:
                 return float(m.group(1))
             # Fallback: generic number of seconds in the message
@@ -249,13 +255,17 @@ class OpenAIModelDriver(LLMDriver):
             # HTTP debug wrapper
             if os.environ.get("OPENAI_DEBUG_HTTP", "0") == "1":
                 from http.client import HTTPConnection
+
                 HTTPConnection.debuglevel = 1
                 logging.basicConfig()
                 logging.getLogger().setLevel(logging.DEBUG)
                 requests_log = logging.getLogger("http.client")
                 requests_log.setLevel(logging.DEBUG)
                 requests_log.propagate = True
-                print("[OpenAIModelDriver] HTTP debug enabled via OPENAI_DEBUG_HTTP=1", flush=True)
+                print(
+                    "[OpenAIModelDriver] HTTP debug enabled via OPENAI_DEBUG_HTTP=1",
+                    flush=True,
+                )
 
             client = openai.OpenAI(**client_kwargs)
             return client
@@ -377,26 +387,32 @@ class OpenAIModelDriver(LLMDriver):
             results = [content]
         for result in results:
             if isinstance(result, dict):
-                api_messages.append({
-                    "role": "tool",
-                    "content": result.get("content", ""),
-                    "name": result.get("name", ""),
-                    "tool_call_id": result.get("tool_call_id", ""),
-                })
+                api_messages.append(
+                    {
+                        "role": "tool",
+                        "content": result.get("content", ""),
+                        "name": result.get("name", ""),
+                        "tool_call_id": result.get("tool_call_id", ""),
+                    }
+                )
             else:
-                api_messages.append({
-                    "role": "tool",
-                    "content": str(result),
-                    "name": "",
-                    "tool_call_id": "",
-                })
+                api_messages.append(
+                    {
+                        "role": "tool",
+                        "content": str(result),
+                        "name": "",
+                        "tool_call_id": "",
+                    }
+                )
 
     def _handle_tool_calls(self, api_messages, content):
         try:
             tool_calls = json.loads(content) if isinstance(content, str) else content
         except Exception:
             tool_calls = []
-        api_messages.append({"role": "assistant", "content": "", "tool_calls": tool_calls})
+        api_messages.append(
+            {"role": "assistant", "content": "", "tool_calls": tool_calls}
+        )
 
     def _handle_other_roles(self, api_messages, msg, role, content):
         if role == "function":
@@ -433,4 +449,4 @@ class OpenAIModelDriver(LLMDriver):
                 )
             )
         # Extend here for other message part types if needed
-        return parts
+        return parts