refactor: fix 2 remaining CodeFlow warnings

Remove unused model param in _send_llm_request, introduce _RetryState dataclass to reduce _handle_validation_result argument count from 11 to 9

Author: sunbos

plugins/sqlseed-ai/src/sqlseed_ai/analyzer.py

@@ -537,14 +537,12 @@ def _send_llm_request(
         self,
         client: Any,
         kwargs: dict[str, Any],
-        model: str | None,
     ) -> Any:
         """Send LLM request with backend-specific strategy (tool calling, JSON mode, text).
 
         Args:
             client: OpenAI client instance.
             kwargs: Request kwargs (will be modified for JSON mode).
-            model: Model ID for error messages.
 
         Returns:
             API response object.
@@ -590,7 +588,7 @@ def _call_llm_once(self, messages: list[dict[str, str]], *, model: str | None =
         try:
             kwargs = self._build_llm_kwargs(model=model)
             kwargs["messages"] = messages
-            response = self._send_llm_request(client, kwargs, model)
+            response = self._send_llm_request(client, kwargs)
         except (APITimeoutError, APIConnectionError, APIError, ValueError, RuntimeError, OSError) as e:
             if isinstance(e, (APITimeoutError, APIConnectionError)):
                 raise

plugins/sqlseed-ai/src/sqlseed_ai/refiner.py

@@ -23,6 +23,18 @@
 logger = get_logger(__name__)
 
 
+class _RetryState:
+    """Mutable state for the refinement retry loop."""
+
+    __slots__ = ("last_error_type", "messages_history", "min_prompt_level", "same_error_count")
+
+    def __init__(self) -> None:
+        self.last_error_type: str | None = None
+        self.same_error_count = 0
+        self.messages_history: list[dict[str, str]] = []
+        self.min_prompt_level: int = 0
+
+
 class AISuggestionFailedError(Exception):
     pass
 
@@ -107,44 +119,37 @@ def _resolve_use_compact(self, use_compact: bool | None) -> bool:
     def _try_prompt_levels(
         self,
         schema_ctx: Any,
-        messages_history: list[dict[str, str]],
-        min_prompt_level: int,
+        state: _RetryState,
         use_compact: bool,
         call_fn: Callable[[list[dict[str, str]]], dict[str, Any] | None],
-    ) -> tuple[dict[str, Any] | None, ErrorSummary | None, int]:
+    ) -> tuple[dict[str, Any] | None, ErrorSummary | None]:
         """Try LLM call across prompt levels with context overflow fallback.
 
         Args:
             schema_ctx: Schema context from the orchestrator.
-            messages_history: Accumulated conversation messages for multi-turn refinement.
-            min_prompt_level: Minimum prompt level index to start from (skips levels
-                that already failed with context overflow).
+            state: Mutable retry state (messages_history, min_prompt_level updated in-place).
             use_compact: Whether to force ultra-compact mode.
             call_fn: Function to call LLM (non-streaming or streaming variant).
 
         Returns:
-            (config_dict, error, new_min_prompt_level)
+            (config_dict or None, error or None)
         """
         prompt_levels = self._get_prompt_levels(use_compact)
         for level_idx, (compact, ultra) in enumerate(prompt_levels):
-            if level_idx < min_prompt_level:
+            if level_idx < state.min_prompt_level:
                 continue
             initial_messages = self._analyzer.build_initial_messages(schema_ctx, compact=compact, ultra_compact=ultra)
-            messages = initial_messages + messages_history
+            messages = initial_messages + state.messages_history
             try:
                 config_dict = call_fn(messages)
                 if not config_dict:
-                    return (
-                        None,
-                        ErrorSummary(
-                            error_type="empty_config",
-                            message="LLM returned empty result",
-                            column=None,
-                            retryable=True,
-                        ),
-                        min_prompt_level,
+                    return None, ErrorSummary(
+                        error_type="empty_config",
+                        message="LLM returned empty result",
+                        column=None,
+                        retryable=True,
                     )
-                return config_dict, None, min_prompt_level
+                return config_dict, None
             except (ValueError, RuntimeError, OSError) as e:
                 err_lower = str(e).lower()
                 if "context" in err_lower and "exceed" in err_lower and not ultra:
@@ -153,10 +158,10 @@ def _try_prompt_levels(
                         compact=compact,
                         ultra_compact=ultra,
                     )
-                    min_prompt_level = level_idx + 1
+                    state.min_prompt_level = level_idx + 1
                     continue
-                return None, summarize_error(e), min_prompt_level
-        return None, None, min_prompt_level
+                return None, summarize_error(e)
+        return None, None
 
     def _handle_validation_result(
         self,
@@ -166,15 +171,13 @@ def _handle_validation_result(
         config_dict: dict[str, Any],
         attempt: int,
         max_retries: int,
-        messages_history: list[dict[str, str]],
-        last_error_type: str | None,
-        same_error_count: int,
+        state: _RetryState,
         on_progress: Callable[[str, dict[str, Any]], None] | None = None,
-    ) -> tuple[dict[str, Any] | None, str | None, int]:
+    ) -> dict[str, Any] | None:
         """Handle validation result: return config on success, or update retry state.
 
         Returns:
-            (config_dict if valid else None, updated last_error_type, updated same_error_count)
+            config_dict if valid, None if validation failed (state updated for next retry).
         """
         val_error = self._validate_config(orch, table_name, config_dict)
 
@@ -183,16 +186,18 @@ def _handle_validation_result(
             self._cache_successful_config(table_name, config_dict, schema_hash)
             if on_progress:
                 on_progress("done", {"tokens": 0, "model": "validated"})
-            return config_dict, last_error_type, same_error_count
+            return config_dict
 
-        last_error_type, same_error_count = self._check_repeated_error(val_error, last_error_type, same_error_count)
+        state.last_error_type, state.same_error_count = self._check_repeated_error(
+            val_error, state.last_error_type, state.same_error_count
+        )
         self._handle_validation_failure(val_error, attempt, max_retries, table_name)
 
-        messages_history.append({"role": "assistant", "content": json.dumps(config_dict, ensure_ascii=False)})
-        messages_history.append(
+        state.messages_history.append({"role": "assistant", "content": json.dumps(config_dict, ensure_ascii=False)})
+        state.messages_history.append(
             {"role": "user", "content": self._build_refinement_prompt(val_error, attempt, max_retries)}
         )
-        return None, last_error_type, same_error_count
+        return None
 
     def _refinement_loop(
         self,
@@ -228,24 +233,18 @@ def _refinement_loop(
                 return cached
 
         resolved_compact = self._resolve_use_compact(use_compact)
-
-        last_error_type: str | None = None
-        same_error_count = 0
-        messages_history: list[dict[str, str]] = []
-        min_prompt_level: int = 0
+        state = _RetryState()
 
         for attempt in range(max_retries + 1):
             if on_progress:
                 on_progress("refining", {"attempt": attempt, "max_retries": max_retries})
 
-            config_dict, error, min_prompt_level = self._try_prompt_levels(
-                schema_ctx, messages_history, min_prompt_level, resolved_compact, call_fn
-            )
+            config_dict, error = self._try_prompt_levels(schema_ctx, state, resolved_compact, call_fn)
 
             if config_dict is None:
                 if error is not None:
-                    last_error_type, same_error_count = self._check_repeated_error(
-                        error, last_error_type, same_error_count
+                    state.last_error_type, state.same_error_count = self._check_repeated_error(
+                        error, state.last_error_type, state.same_error_count
                     )
                     self._handle_generation_failure(error, attempt, max_retries)
                 continue
@@ -254,16 +253,14 @@ def _refinement_loop(
             if on_progress:
                 on_progress("validating", {"attempt": attempt})
 
-            result, last_error_type, same_error_count = self._handle_validation_result(
+            result = self._handle_validation_result(
                 orch,
                 table_name,
                 schema_hash,
                 config_dict,
                 attempt,
                 max_retries,
-                messages_history,
-                last_error_type,
-                same_error_count,
+                state,
                 on_progress,
             )
             if result is not None: