fix: address PR review findings

- remove global OpenAI client/api mutations (race condition with concurrent agents)
- add empty resolved_agents validation before deploy_task_agents
- store toolbox name on MCPServerEntry instead of accessing private _name
- update last_tool_results unconditionally in session.record_task
- move raises into match default cases to fix mixed return warnings
- catch non-SystemExit exceptions in prompt parser

Author: anticomputer

src/seclab_taskflow_agent/agent.py

@@ -19,8 +19,6 @@
     TContext,
     Tool,
     result,
-    set_default_openai_api,
-    set_default_openai_client,
     set_tracing_disabled,
 )
 from agents.agent import FunctionToolResult, ModelSettings, ToolsToFinalOutputResult
@@ -196,8 +194,6 @@ def __init__(
             api_key=resolved_token,
             default_headers={"Copilot-Integration-Id": COPILOT_INTEGRATION_ID},
         )
-        set_default_openai_client(client)
-        set_default_openai_api(api_type)
         set_tracing_disabled(True)
         self.run_hooks = run_hooks or TaskRunHooks()
 

src/seclab_taskflow_agent/capi.py

@@ -37,7 +37,8 @@ def to_url(self) -> str:
                 return f"https://{self}/inference"
             case AI_API_ENDPOINT_ENUM.AI_API_OPENAI:
                 return f"https://{self}/v1"
-        raise ValueError(f"Unsupported endpoint: {self}")
+            case _:
+                raise ValueError(f"Unsupported endpoint: {self}")
 
 
 COPILOT_INTEGRATION_ID = "vscode-chat"
@@ -121,10 +122,11 @@ def supports_tool_calls(model: str, models: dict[str, dict]) -> bool:
             return "tool-calling" in models.get(model, {}).get("capabilities", [])
         case AI_API_ENDPOINT_ENUM.AI_API_OPENAI:
             return "gpt-" in model.lower()
-    raise ValueError(
-        f"Unsupported Model Endpoint: {api_endpoint}\n"
-        f"Supported endpoints: {[e.to_url() for e in AI_API_ENDPOINT_ENUM]}"
-    )
+        case _:
+            raise ValueError(
+                f"Unsupported Model Endpoint: {api_endpoint}\n"
+                f"Supported endpoints: {[e.to_url() for e in AI_API_ENDPOINT_ENUM]}"
+            )
 
 
 def list_tool_call_models(token: str) -> dict[str, dict]:

src/seclab_taskflow_agent/mcp_lifecycle.py

@@ -33,11 +33,12 @@
 class MCPServerEntry:
     """A paired MCP server wrapper and optional local process."""
 
-    __slots__ = ("server", "process")
+    __slots__ = ("server", "process", "name")
 
-    def __init__(self, server: MCPNamespaceWrap, process: StreamableMCPThread | None = None):
+    def __init__(self, server: MCPNamespaceWrap, process: StreamableMCPThread | None = None, name: str = ""):
         self.server = server
         self.process = process
+        self.name = name
 
 
 def build_mcp_servers(
@@ -117,7 +118,7 @@ def _print_err(line: str) -> None:
             case _:
                 raise ValueError(f"Unsupported MCP transport: {params['kind']}")
 
-        entries.append(MCPServerEntry(MCPNamespaceWrap(confirms, mcp_server), server_proc))
+        entries.append(MCPServerEntry(MCPNamespaceWrap(confirms, mcp_server), server_proc, name=tb))
 
     return entries
 
@@ -136,7 +137,7 @@ async def mcp_session_task(
     """
     try:
         for entry in entries:
-            logging.debug(f"Connecting mcp server: {entry.server._name}")
+            logging.debug(f"Connecting mcp server: {entry.name}")
             if entry.process is not None:
                 entry.process.start()
                 await entry.process.async_wait_for_connection(poll_interval=0.1)
@@ -147,17 +148,17 @@ async def mcp_session_task(
 
         for entry in list(reversed(entries)):
             try:
-                logging.debug(f"Starting cleanup for mcp server: {entry.server._name}")
+                logging.debug(f"Starting cleanup for mcp server: {entry.name}")
                 await entry.server.cleanup()
-                logging.debug(f"Cleaned up mcp server: {entry.server._name}")
+                logging.debug(f"Cleaned up mcp server: {entry.name}")
                 if entry.process is not None:
                     entry.process.stop()
                     try:
                         await asyncio.to_thread(entry.process.join_and_raise)
                     except Exception as e:
                         logging.warning(f"Streamable mcp server process exception: {e}")
             except asyncio.CancelledError:
-                logging.exception(f"Timeout on cleanup for mcp server: {entry.server._name}")
+                logging.exception(f"Timeout on cleanup for mcp server: {entry.name}")
     except RuntimeError:
         logging.exception("RuntimeError in mcp session task")
     except asyncio.CancelledError:

src/seclab_taskflow_agent/prompt_parser.py

@@ -54,6 +54,9 @@ def parse_prompt_args(
         if e.code == 2:
             logging.exception(f"User provided incomplete prompt: {user_prompt}")
         return None, None, None, None, "", help_msg
+    except Exception:
+        logging.exception(f"Failed to parse 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
     list_models = args[0].l

src/seclab_taskflow_agent/runner.py

@@ -603,6 +603,12 @@ async def run_prompts(async_task: bool = False, max_concurrent_tasks: int = 5) -
                                 raise ValueError(f"No such personality: {agent_name}")
                             resolved_agents[agent_name] = personality
 
+                        if not resolved_agents:
+                            raise ValueError(
+                                "No agents resolved for this task. "
+                                "Specify a personality with -p or provide an agents list."
+                            )
+
                         async def _deploy(ra: dict, pp: str) -> bool:
                             async with semaphore:
                                 return await deploy_task_agents(

src/seclab_taskflow_agent/session.py

@@ -99,8 +99,7 @@ def record_task(
                 tool_results=tool_results or [],
             )
         )
-        if tool_results:
-            self.last_tool_results = list(tool_results)
+        self.last_tool_results = list(tool_results or [])
         self.save()
 
     def mark_finished(self) -> None: