Merge branch 'main' into p--fix-cmd-samples

Author: p-

README.md

@@ -30,7 +30,7 @@ Instead of generating CodeQL queries itself, the CodeQL MCP Server is used to pr
 
 ## Requirements
 
-Python >= 3.9 or Docker
+Python >= 3.10 or Docker
 
 ## Configuration
 

pyproject.toml

@@ -7,7 +7,7 @@ name = "seclab-taskflow-agent"
 dynamic = ["version"]
 description = "A taskflow agent for the SecLab project, enabling secure and automated workflow execution."
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "MIT"
 keywords = []
 authors = [
@@ -16,8 +16,6 @@ authors = [
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.8",
-  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",

release_tools/copy_files.py

@@ -3,16 +3,16 @@
 
 import os
 import shutil
-import sys
 import subprocess
+import sys
 
 
 def read_file_list(list_path):
     """
     Reads a file containing file paths, ignoring empty lines and lines starting with '#'.
     Returns a list of relative file paths.
     """
-    with open(list_path, "r") as f:
+    with open(list_path) as f:
         lines = [line.strip() for line in f]
     return [line for line in lines if line and not line.startswith("#")]
 

release_tools/publish_docker.py

@@ -1,8 +1,6 @@
 # SPDX-FileCopyrightText: 2025 GitHub
 # SPDX-License-Identifier: MIT
 
-import os
-import shutil
 import subprocess
 import sys
 

src/seclab_taskflow_agent/__main__.py

@@ -1,48 +1,46 @@
 # SPDX-FileCopyrightText: 2025 GitHub
 # SPDX-License-Identifier: MIT
 
-import asyncio
-from threading import Thread
 import argparse
-import os
-import sys
-from dotenv import load_dotenv, find_dotenv
+import asyncio
+import json
 import logging
-from logging.handlers import RotatingFileHandler
-from pprint import pprint, pformat
+import os
+import pathlib
 import re
-import json
+import sys
 import uuid
-import pathlib
+from collections.abc import Callable
+from logging.handlers import RotatingFileHandler
+from pprint import pformat
 
-from .agent import DEFAULT_MODEL, TaskRunHooks, TaskAgentHooks
+from agents import Agent, RunContextWrapper, TContext, Tool
+from agents.agent import ModelSettings
 
 # from agents.run import DEFAULT_MAX_TURNS # XXX: this is 10, we need more than that
-from agents.exceptions import MaxTurnsExceeded, AgentsException
-from agents.agent import ModelSettings
-from agents.mcp import MCPServer, MCPServerStdio, MCPServerSse, MCPServerStreamableHttp, create_static_tool_filter
+from agents.exceptions import AgentsException, MaxTurnsExceeded
 from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
-from agents import Tool, RunContextWrapper, TContext, Agent
-from openai import BadRequestError, APITimeoutError, RateLimitError
+from agents.mcp import MCPServerSse, MCPServerStdio, MCPServerStreamableHttp, create_static_tool_filter
+from dotenv import find_dotenv, load_dotenv
+from openai import APITimeoutError, BadRequestError, RateLimitError
 from openai.types.responses import ResponseTextDeltaEvent
-from typing import Callable
 
-from .shell_utils import shell_tool_call
+from .agent import DEFAULT_MODEL, TaskAgent, TaskAgentHooks, TaskRunHooks
+from .available_tools import AvailableTools
+from .capi import get_AI_token, list_tool_call_models
+from .env_utils import TmpEnv
 from .mcp_utils import (
     DEFAULT_MCP_CLIENT_SESSION_TIMEOUT,
-    ReconnectingMCPServerStdio,
     MCPNamespaceWrap,
-    mcp_client_params,
-    mcp_system_prompt,
+    ReconnectingMCPServerStdio,
     StreamableMCPThread,
     compress_name,
+    mcp_client_params,
+    mcp_system_prompt,
 )
-from .render_utils import render_model_output, flush_async_output
-from .env_utils import TmpEnv
-from .agent import TaskAgent
-from .capi import list_tool_call_models, get_AI_token
-from .available_tools import AvailableTools
 from .path_utils import log_file_name
+from .render_utils import flush_async_output, render_model_output
+from .shell_utils import shell_tool_call
 
 load_dotenv(find_dotenv(usecwd=True))
 
@@ -90,7 +88,7 @@ def parse_prompt_args(available_tools: AvailableTools, user_prompt: str | None =
         args = parser.parse_known_args(user_prompt.split(" ") if user_prompt else None)
     except SystemExit as e:
         if e.code == 2:
-            logging.error(f"User provided incomplete prompt: {user_prompt}")
+            logging.exception(f"User provided incomplete prompt: {user_prompt}")
             return None, None, None, None, help_msg
     p = args[0].p.strip() if args[0].p else None
     t = args[0].t.strip() if args[0].t else None
@@ -257,14 +255,13 @@ async def mcp_session_task(mcp_servers: list, connected: asyncio.Event, cleanup:
                         except Exception as e:
                             print(f"Streamable mcp server process exception: {e}")
                 except asyncio.CancelledError:
-                    logging.error(f"Timeout on cleanup for mcp server: {server._name}")
+                    logging.exception(f"Timeout on cleanup for mcp server: {server._name}")
                 finally:
                     mcp_servers.remove(s)
         except RuntimeError as e:
-            logging.error(f"RuntimeError in mcp session task: {e}")
+            logging.exception("RuntimeError in mcp session task")
         except asyncio.CancelledError as e:
-            logging.error(f"Timeout on main session task: {e}")
-            pass
+            logging.exception("Timeout on main session task")
         finally:
             mcp_servers.clear()
 
@@ -352,17 +349,17 @@ async def _run_streamed():
                         return
                     except APITimeoutError:
                         if not max_retry:
-                            logging.error(f"Max retries for APITimeoutError reached")
+                            logging.exception("Max retries for APITimeoutError reached")
                             raise
                         max_retry -= 1
                     except RateLimitError:
                         if rate_limit_backoff == MAX_RATE_LIMIT_BACKOFF:
-                            raise APITimeoutError(f"Max rate limit backoff reached")
+                            raise APITimeoutError("Max rate limit backoff reached")
                         if rate_limit_backoff > MAX_RATE_LIMIT_BACKOFF:
                             rate_limit_backoff = MAX_RATE_LIMIT_BACKOFF
                         else:
                             rate_limit_backoff += rate_limit_backoff
-                        logging.error(f"Hit rate limit ... holding for {rate_limit_backoff}")
+                        logging.exception(f"Hit rate limit ... holding for {rate_limit_backoff}")
                         await asyncio.sleep(rate_limit_backoff)
 
             await _run_streamed()
@@ -371,16 +368,16 @@ async def _run_streamed():
         # raise exceptions up to here for anything that indicates a task failure
         except MaxTurnsExceeded as e:
             await render_model_output(f"** 🤖❗ Max Turns Reached: {e}\n", async_task=async_task, task_id=task_id)
-            logging.error(f"Exceeded max_turns: {max_turns}")
+            logging.exception(f"Exceeded max_turns: {max_turns}")
         except AgentsException as e:
             await render_model_output(f"** 🤖❗ Agent Exception: {e}\n", async_task=async_task, task_id=task_id)
-            logging.error(f"Agent Exception: {e}")
+            logging.exception("Agent Exception")
         except BadRequestError as e:
             await render_model_output(f"** 🤖❗ Request Error: {e}\n", async_task=async_task, task_id=task_id)
-            logging.error(f"Bad Request: {e}")
+            logging.exception("Bad Request")
         except APITimeoutError as e:
             await render_model_output(f"** 🤖❗ Timeout Error: {e}\n", async_task=async_task, task_id=task_id)
-            logging.error(f"Bad Request: {e}")
+            logging.exception("Bad Request")
 
         if async_task:
             await flush_async_output(task_id)
@@ -391,14 +388,14 @@ async def _run_streamed():
         # signal mcp sessions task that it can disconnect our servers
         start_cleanup.set()
         cleanup_attempts_left = len(mcp_servers)
-        while cleanup_attempts_left and len(mcp_servers):
+        while cleanup_attempts_left and mcp_servers:
             try:
                 cleanup_attempts_left -= 1
                 await asyncio.wait_for(mcp_sessions, timeout=MCP_CLEANUP_TIMEOUT)
-            except asyncio.TimeoutError as e:
+            except asyncio.TimeoutError:
                 continue
             except Exception as e:
-                logging.error(f"Exception in mcp server cleanup task: {e}")
+                logging.exception("Exception in mcp server cleanup task")
 
 
 async def main(available_tools: AvailableTools, p: str | None, t: str | None, cli_globals: dict, prompt: str | None):
@@ -580,15 +577,15 @@ def preprocess_prompt(prompt: str, tag: str, kv: Callable[[str], dict], kv_subke
                 async def run_prompts(async_task=False, max_concurrent_tasks=5):
                     # if this is a shell task, execute that and append the results
                     if run:
-                        await render_model_output(f"** 🤖🐚 Executing Shell Task\n")
+                        await render_model_output("** 🤖🐚 Executing Shell Task\n")
                         # this allows e.g. shell based jq output to become available for repeat prompts
                         try:
                             result = shell_tool_call(run).content[0].model_dump_json()
                             last_mcp_tool_results.append(result)
                             return True
                         except RuntimeError as e:
                             await render_model_output(f"** 🤖❗ Shell Task Exception: {e}\n")
-                            logging.error(f"Shell task error: {e}")
+                            logging.exception("Shell task error")
                             return False
 
                     tasks = []

src/seclab_taskflow_agent/agent.py

@@ -2,34 +2,32 @@
 # SPDX-License-Identifier: MIT
 
 # https://openai.github.io/openai-agents-python/agents/
-import os
 import logging
-from dotenv import load_dotenv, find_dotenv
+import os
 from collections.abc import Callable
 from typing import Any
 from urllib.parse import urlparse
 
-from openai import AsyncOpenAI
-from agents.agent import ModelSettings, ToolsToFinalOutputResult, FunctionToolResult
-from agents.run import DEFAULT_MAX_TURNS
-from agents.run import RunHooks
 from agents import (
     Agent,
-    Runner,
     AgentHooks,
-    RunHooks,
-    result,
-    function_tool,
-    Tool,
+    OpenAIChatCompletionsModel,
     RunContextWrapper,
+    RunHooks,
+    Runner,
     TContext,
-    OpenAIChatCompletionsModel,
-    set_default_openai_client,
+    Tool,
+    result,
     set_default_openai_api,
+    set_default_openai_client,
     set_tracing_disabled,
 )
+from agents.agent import FunctionToolResult, ModelSettings, ToolsToFinalOutputResult
+from agents.run import DEFAULT_MAX_TURNS, RunHooks
+from dotenv import find_dotenv, load_dotenv
+from openai import AsyncOpenAI
 
-from .capi import COPILOT_INTEGRATION_ID, get_AI_endpoint, get_AI_token, AI_API_ENDPOINT_ENUM
+from .capi import AI_API_ENDPOINT_ENUM, COPILOT_INTEGRATION_ID, get_AI_endpoint, get_AI_token
 
 # grab our secrets from .env, this must be in .gitignore
 load_dotenv(find_dotenv(usecwd=True))

src/seclab_taskflow_agent/available_tools.py

@@ -1,9 +1,9 @@
 # SPDX-FileCopyrightText: 2025 GitHub
 # SPDX-License-Identifier: MIT
 
-from enum import Enum
-import logging
 import importlib.resources
+from enum import Enum
+
 import yaml
 
 

src/seclab_taskflow_agent/capi.py

@@ -2,13 +2,14 @@
 # SPDX-License-Identifier: MIT
 
 # CAPI specific interactions
-import httpx
 import json
 import logging
 import os
-from strenum import StrEnum
 from urllib.parse import urlparse
 
+import httpx
+from strenum import StrEnum
+
 
 # Enumeration of currently supported API endpoints.
 class AI_API_ENDPOINT_ENUM(StrEnum):
@@ -96,11 +97,11 @@ def list_capi_models(token: str) -> dict[str, dict]:
         for model in models_list:
             models[model.get("id")] = dict(model)
     except httpx.RequestError as e:
-        logging.error(f"Request error: {e}")
+        logging.exception("Request error")
     except json.JSONDecodeError as e:
-        logging.error(f"JSON error: {e}")
+        logging.exception("JSON error")
     except httpx.HTTPStatusError as e:
-        logging.error(f"HTTP error: {e}")
+        logging.exception("HTTP error")
     return models
 
 

src/seclab_taskflow_agent/env_utils.py

@@ -1,8 +1,8 @@
 # SPDX-FileCopyrightText: 2025 GitHub
 # SPDX-License-Identifier: MIT
 
-import re
 import os
+import re
 
 
 def swap_env(s):