superqode 2.4.41__tar.gz → 2.4.42__tar.gz

{superqode-2.4.41 → superqode-2.4.42}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.42] - 2026-10-02
+
+### Fixed
+
+- Distinguish exhausted API quota from temporary rate limits, skip futile quota
+  retries, and avoid repeating rate-limited streams as non-streaming requests.
+- Route GPT-6.1 Sol and GPT-6 Astra through OpenAI Responses for Core tool calls,
+  preserve native streaming and reasoning effort with older LiteLLM catalogs,
+  omit unsupported sampling controls, and report invalid requests immediately
+  instead of repeating them without streaming.
+- Allow read-only shell commands to discard output through `/dev/null` while
+  continuing to block device writes and require approval for file writes.
+- Keep experimental subscription guidance concise and remove internal adapter
+  and testing details from the connection picker.
+- Explain that a denied tool call does not imply all repository access is blocked.
+
 ## [2.4.41] - 2026-10-01
 
 ### Fixed

{superqode-2.4.41 → superqode-2.4.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.41
+Version: 2.4.42
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.4.41 → superqode-2.4.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.4.41"
+version = "2.4.42"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-2.4.41 → superqode-2.4.42}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.4.41"
+__version__ = "2.4.42"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.4.41 → superqode-2.4.42}/src/superqode/agent/command_safety.py

@@ -203,7 +203,7 @@ _DESTRUCTIVE_PATTERNS = [
     r"\bmkfs\.",
     r"\bdd\b[^|]*\bof=",
     r":\s*\(\s*\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:",  # fork bomb
-    r">\s*/dev/(sd|nvme|disk|hd)",
+    r">\s*/dev/(?!null(?:\s|[;&|)]|$))",
     r"\bchmod\s+(-R\s+)?0?777\b",
     r"\bchown\s+-R\b",
     r"\b(shutdown|reboot|halt|poweroff)\b",
@@ -286,8 +286,10 @@ def _classify_segment(segment: str) -> CommandSafety:
     if not cmd:
         return CommandSafety.WRITE
 
-    # Redirection to a file in this segment implies a write at minimum.
-    has_file_redirect = bool(re.search(r">>?\s*[^&\s]", segment))
+    # Discarding output does not modify a file. Other destinations still
+    # require write permission, including lookalikes such as /dev/null.log.
+    targets = re.findall(r">>?\s*([^&\s]+)", segment)
+    has_file_redirect = any(target != "/dev/null" for target in targets)
 
     first_arg = next((a for a in args if not a.startswith("-")), "")
 

{superqode-2.4.41 → superqode-2.4.42}/src/superqode/agent/loop.py

@@ -36,7 +36,15 @@ from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional
 
 from ..tools.base import Tool, ToolContext, ToolRegistry, ToolResult
 from ..tools.permissions import Permission, PermissionConfig, PermissionManager
-from ..providers.gateway.base import GatewayInterface, Message, ToolDefinition
+from ..providers.gateway.base import (
+    AuthenticationError,
+    GatewayInterface,
+    InvalidRequestError,
+    Message,
+    ModelNotFoundError,
+    RateLimitError,
+    ToolDefinition,
+)
 from .system_prompts import (
     SystemPromptLevel,
     get_system_prompt,
@@ -1584,7 +1592,10 @@ class AgentLoop:
             return ToolResult(
                 success=False,
                 output="",
-                error=f"Permission denied for tool: {name}",
+                error=(
+                    f"Permission policy blocked this {name} tool call. "
+                    "This does not mean repository access is unavailable; try an allowed read tool or a simpler read-only command."
+                ),
                 metadata={"permission": "deny", "tool": name},
             )
 
@@ -3268,6 +3279,13 @@ class AgentLoop:
                     thinking_buffer = ""
 
             except Exception as e:
+                if isinstance(
+                    e,
+                    (InvalidRequestError, AuthenticationError, ModelNotFoundError, RateLimitError),
+                ):
+                    self.last_stream_error = str(e)
+                    yield f"\n\n[Error: {type(e).__name__}] {e}"
+                    return
                 # Flush thinking buffer before handling error
                 if thinking_buffer.strip() and self.on_thinking:
                     await self.on_thinking(thinking_buffer.strip())

{superqode-2.4.41 → superqode-2.4.42}/src/superqode/app/mixins/connect.py

@@ -1898,7 +1898,6 @@ class ConnectMixin:
             self._reset_connect_selection_states()
             self._open_connect_screen(log)
             log.add_info(profile.unavailable_hint)
-            log.add_info("Your current harness and model have been kept.")
             return
         self._connection_retry_target = ("profile", (profile.id,))
         self._connection_attempt_state = "Setup"

{superqode-2.4.41 → superqode-2.4.42}/src/superqode/providers/connection_profiles.py

@@ -697,9 +697,7 @@ _PLAN_PROFILES = [
         detect=lambda: False,
         unavailable_hint=(
             f"{profile.label.split(' (')[0].split(' —')[0]}: Partner integration in progress. "
-            "Subscription access is not enabled through this experimental entry. "
-            "Provider access, adapter implementation and live testing must be confirmed "
-            "before it can connect. No credentials are requested or API-credit fallback used."
+            "Subscription connection is not available yet."
         ),
     )
     for profile in _PLAN_PROFILES
@@ -1634,7 +1632,7 @@ CONNECT_MENU_TITLES = {
     ),
     CONNECT_MENU_PLAN: (
         "Use your subscription (Experimental)",
-        "Keeps your selected SuperQode harness. Partner integration in progress for all providers. Information only; no subscription connection is enabled here.",
+        "Partner integration in progress. Subscription connections are not available yet.",
     ),
     CONNECT_MENU_BUILD: (
         "Build your own harness (Advanced)",

{superqode-2.4.41 → superqode-2.4.42}/src/superqode/providers/gateway/litellm_gateway.py

@@ -221,6 +221,8 @@ class LiteLLMGateway(GatewayInterface):
             # OpenAI models should always be provider-qualified for LiteLLM
             # to avoid "LLM Provider NOT provided" on newer model IDs.
             if provider == "openai":
+                if self._requires_openai_responses(provider, model):
+                    return f"openai/responses/{model.split('/')[-1]}"
                 if model.startswith("openai/"):
                     return model
                 return f"openai/{model}"
@@ -234,6 +236,38 @@ class LiteLLMGateway(GatewayInterface):
         # Unknown provider - try as-is
         return model
 
+    @staticmethod
+    def _requires_openai_responses(provider: str, model: str) -> bool:
+        """These models require Responses for the agent's function calls."""
+        model_id = model.split("/")[-1]
+        return provider == "openai" and any(
+            model_id == name or model_id.startswith(f"{name}-")
+            for name in ("gpt-6.1-sol", "gpt-6-astra")
+        )
+
+    @classmethod
+    def _apply_openai_responses_shaping(
+        cls, provider: str, model: str, request_kwargs: Dict[str, Any]
+    ) -> None:
+        if not cls._requires_openai_responses(provider, model):
+            return
+        # These models always reason and reject sampling controls.
+        for key in ("temperature", "top_p", "top_logprobs", "logprobs"):
+            request_kwargs.pop(key, None)
+        extra_body = dict(request_kwargs.get("extra_body") or {})
+        if request_kwargs.get("stream"):
+            # Preserve streaming through LiteLLM's Chat-to-Responses bridge.
+            extra_body["stream"] = True
+        effort = request_kwargs.pop("reasoning_effort", None)
+        if effort is not None:
+            if effort in ("none", "minimal", "off"):
+                effort = "low"
+            # Older LiteLLM model tables drop reasoning_effort for new IDs.
+            # Its Responses bridge accepts the native shape through extra_body.
+            extra_body["reasoning"] = {"effort": effort}
+        if extra_body:
+            request_kwargs["extra_body"] = extra_body
+
     def _get_model_candidates(self, provider: str, model: str) -> List[str]:
         """Return model candidates to try in order for provider/model pair."""
         primary = self.get_model_string(provider, model) if provider != "unknown" else model
@@ -287,9 +321,43 @@ class LiteLLMGateway(GatewayInterface):
     # the error instead of silently hanging an interactive session.
     _RATE_LIMIT_MAX_HONORED_RETRY_AFTER = 60.0
 
-    @staticmethod
-    def _is_transient_overload_error(error: Exception) -> bool:
+    _QUOTA_ERROR_HINTS = {
+        "insufficient_quota": "Check API credits and the usage limits for this key's project and organization.",
+        "credit_balance_exhausted": "The API credit balance is exhausted. Check API billing.",
+        "organization_usage_limit_exceeded": "The organization API usage limit was reached. Check its limits.",
+        "organization_spend_limit_exceeded": "The organization API spend limit was reached. Check its limits.",
+        "project_spend_limit_exceeded": "The project API spend limit was reached. Check its limits.",
+    }
+
+    @classmethod
+    def _quota_error_code(cls, error: Exception) -> Optional[str]:
+        """Identify permanent quota failures without displaying raw response data."""
+        body = getattr(error, "body", None)
+        if not isinstance(body, dict):
+            response = getattr(error, "response", None)
+            try:
+                body = response.json() if response is not None else None
+            except Exception:
+                body = None
+        if isinstance(body, dict):
+            details = body.get("error", body)
+            if isinstance(details, dict):
+                for field in ("code", "type"):
+                    code = details.get(field)
+                    if isinstance(code, str) and code in cls._QUOTA_ERROR_HINTS:
+                        return code
+        # Some LiteLLM adapters retain the provider code only in the message.
+        message = str(error).lower()
+        for code in cls._QUOTA_ERROR_HINTS:
+            if code in message:
+                return code
+        return None
+
+    @classmethod
+    def _is_transient_overload_error(cls, error: Exception) -> bool:
         """Rate limits / momentary overload: the same request can succeed shortly."""
+        if cls._quota_error_code(error) is not None:
+            return False
         if "ratelimit" in type(error).__name__.lower():
             return True
         msg = str(error).lower()
@@ -368,6 +436,25 @@ class LiteLLMGateway(GatewayInterface):
         # sends ordinary model tool definitions here, so bypass that handler.
         request_kwargs.setdefault("_skip_mcp_handler", True)
         litellm = self._get_litellm()
+        routed_model = request_kwargs.get("model", "")
+        if routed_model.startswith("openai/responses/") and self._requires_openai_responses(
+            "openai", routed_model
+        ):
+            # Unknown models are fake-streamed by older LiteLLM catalogs.
+            # Register capabilities only, retaining any existing pricing metadata.
+            model_id = routed_model.split("/")[-1]
+            model_key = f"openai/{model_id}"
+            info = dict(litellm.model_cost.get(model_key, litellm.model_cost.get(model_id, {})))
+            capabilities = dict(
+                llm_provider="openai",
+                mode="responses",
+                supports_native_streaming=True,
+                supports_function_calling=True,
+                supports_reasoning=True,
+            )
+            if any(info.get(key) != value for key, value in capabilities.items()):
+                info.update(capabilities)
+                litellm.register_model({model_key: info})
         retries = self._rate_limit_retries()
         attempt = 0
         while True:
@@ -713,6 +800,8 @@ class LiteLLMGateway(GatewayInterface):
             return {"reasoning_effort": "max"}
 
         model_lower = (model or "").lower()
+        if self._requires_openai_responses(provider, model):
+            return {"reasoning_effort": "low" if level == "off" else level}
         is_anthropic_shape = (
             provider == "anthropic" or provider == "ds4" or "deepseek-v4" in model_lower
         )
@@ -1148,12 +1237,23 @@ class LiteLLMGateway(GatewayInterface):
             ) from e
 
         if isinstance(e, litellm.RateLimitError):
+            quota_code = self._quota_error_code(e)
+            if quota_code:
+                message = (
+                    f"API quota blocked '{provider}' ({quota_code}). "
+                    f"{self._QUOTA_ERROR_HINTS[quota_code]} Retrying will not restore access."
+                )
+            else:
+                message = (
+                    f"Rate limit reached for '{provider}/{model}'. "
+                    "Wait before retrying and check this model's API request/token limits."
+                )
             raise RateLimitError(
-                f"Rate limit exceeded for provider '{provider}'. "
-                "Wait and retry, or upgrade your API plan.",
+                message,
                 provider=provider,
                 model=model,
-                error_type="rate_limit",
+                error_type=quota_code or "rate_limit",
+                status_code=429,
             ) from e
 
         if isinstance(e, litellm.NotFoundError):
@@ -2422,6 +2522,7 @@ class LiteLLMGateway(GatewayInterface):
         # Applied after kwargs merge so user overrides via extra kwargs win.
         self._apply_local_request_shaping(provider, model, request_kwargs, bool(tools))
         self._apply_kimi_k3_request_shaping(provider, model, request_kwargs)
+        self._apply_openai_responses_shaping(provider, model, request_kwargs)
 
         try:
             model_candidates = self._get_model_candidates(provider, model)
@@ -2706,6 +2807,7 @@ class LiteLLMGateway(GatewayInterface):
         # Local-model tuning. Same rationale as in chat_completion.
         self._apply_local_request_shaping(provider, model, request_kwargs, bool(tools))
         self._apply_kimi_k3_request_shaping(provider, model, request_kwargs)
+        self._apply_openai_responses_shaping(provider, model, request_kwargs)
 
         try:
             model_candidates = self._get_model_candidates(provider, model)

{superqode-2.4.41 → superqode-2.4.42}/src/superqode/tools/permissions.py

@@ -230,7 +230,6 @@ class PermissionManager:
             r"rm\s+-[^-]*r",
             r"sudo\s+",
             r"chmod\s+777",
-            r">\s*/dev/",
             r"mkfs\.",
             r"dd\s+if=",
             r":(){ :|:& };:",  # Fork bomb

{superqode-2.4.41 → superqode-2.4.42}/src/superqode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.41
+Version: 2.4.42
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.4.41 → superqode-2.4.42}/src/superqode.egg-info/SOURCES.txt

@@ -1024,6 +1024,7 @@ tests/test_network_policy.py
 tests/test_ollama_client.py
 tests/test_omnigent_agent_session_smoke.py
 tests/test_omnigent_importer.py
+tests/test_openai_responses_routing.py
 tests/test_openai_session.py
 tests/test_optimize_harnesses.py
 tests/test_output_spill.py

{superqode-2.4.41 → superqode-2.4.42}/tests/test_agent_loop_harness.py

@@ -98,6 +98,41 @@ def _loop(gateway: ScriptedGateway, *, require_confirmation: bool = False) -> Ag
     )
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "error_name",
+    ["InvalidRequestError", "AuthenticationError", "ModelNotFoundError", "RateLimitError"],
+)
+async def test_streaming_terminal_provider_error_is_not_repeated(error_name):
+    from superqode.providers.gateway import base
+
+    class RejectedGateway(ScriptedGateway):
+        async def stream_completion(self, *args, **kwargs):
+            raise getattr(base, error_name)("request rejected")
+            yield  # Keep the async iterator interface.
+
+    gateway = RejectedGateway([])
+    loop = _loop(gateway)
+    output = "".join([chunk async for chunk in loop.run_streaming("read README")])
+    assert error_name in output
+    assert loop.last_stream_error == "request rejected"
+    assert gateway.calls == []  # No second, non-streaming provider request.
+
+
+@pytest.mark.asyncio
+async def test_streaming_transport_error_still_uses_nonstreaming_fallback():
+    class InterruptedGateway(ScriptedGateway):
+        async def stream_completion(self, *args, **kwargs):
+            raise ConnectionError("stream disconnected")
+            yield
+
+    gateway = InterruptedGateway([GatewayResponse(content="Recovered answer")])
+    loop = _loop(gateway)
+    output = "".join([chunk async for chunk in loop.run_streaming("hi")])
+    assert output == "Recovered answer"
+    assert len(gateway.calls) == 1
+
+
 def test_agent_loop_loads_parent_and_local_project_instructions(tmp_path):
     root = tmp_path / "repo"
     nested = root / "src" / "pkg"
@@ -139,7 +174,8 @@ async def test_agent_loop_blocks_dangerous_shell_commands_before_execution():
 
     assert result.content == "saw denial"
     assert result.tool_calls_made == 1
-    assert "Permission denied for tool: bash" in result.messages[-1].content
+    assert "Permission policy blocked this bash tool call" in result.messages[-1].content
+    assert "try an allowed read tool" in result.messages[-1].content
 
 
 @pytest.mark.asyncio

{superqode-2.4.41 → superqode-2.4.42}/tests/test_command_safety.py

@@ -145,3 +145,42 @@ def test_permission_manager_auto_allows_safe_and_denies_destructive():
     assert manager.check_permission("bash", {"command": "git commit -m x"}) == Permission.ASK
     # ... and destructive commands are blocked outright.
     assert manager.check_permission("bash", {"command": "rm -rf /"}) == Permission.DENY
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "ls README* 2>/dev/null",
+        "ls README* 2>>/dev/null",
+        "git status >/dev/null",
+        'ls README* 2>"/dev/null"',
+        'ls -la && echo "---" && find . -maxdepth 2 -type d -not -path \'*/.*\' | head -80 && echo "---README---" && ls -la README* 2>/dev/null; ls *.md 2>/dev/null | head -20',
+    ],
+)
+def test_output_suppression_remains_read_only(command):
+    from superqode.tools.permissions import Permission, PermissionManager
+
+    assert classify_command(command) == CommandSafety.SAFE
+    assert PermissionManager().check_permission("bash", {"command": command}) == Permission.ALLOW
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "echo x >/dev/disk0",
+        "echo x >'/dev/sda'",
+        "echo x >/dev/random",
+        "echo x >/dev/null.log",
+        "echo x >/dev/null/disk",
+    ],
+)
+def test_output_suppression_exception_cannot_bypass_device_guard(command):
+    from superqode.tools.permissions import Permission, PermissionManager
+
+    assert classify_command(command) == CommandSafety.DESTRUCTIVE
+    assert PermissionManager().check_permission("bash", {"command": command}) == Permission.DENY
+
+
+def test_null_suppression_does_not_hide_other_writes():
+    assert classify_command("ls 2>/dev/null >listing.txt") == CommandSafety.WRITE
+    assert classify_command("ls 2>/dev/null; rm -rf project") == CommandSafety.DESTRUCTIVE

{superqode-2.4.41 → superqode-2.4.42}/tests/test_connect_harness_screen.py

@@ -1272,6 +1272,9 @@ def test_subscription_is_a_real_menu_not_a_printed_list():
         assert profile.connector == "plan-guidance"
         assert "Partner integration in progress" in profile.label
         assert "Partner integration in progress" in profile.unavailable_hint
+        assert "Subscription connection is not available yet." in profile.unavailable_hint
+        assert "adapter" not in profile.unavailable_hint
+        assert "credentials" not in profile.unavailable_hint
         assert not profile.available
         assert "claude" not in profile.label.casefold()
         assert "anthropic" not in profile.label.casefold()

{superqode-2.4.41 → superqode-2.4.42}/tests/test_connect_subscription_routes.py

@@ -49,7 +49,8 @@ def test_unsupported_native_plan_preserves_current_model(profile):
     assert app.current_harness == "pipy"
     assert app.current_model == "existing-model"
     assert app.calls == []
-    assert any("kept" in message for message in log.messages)
+    assert len(log.messages) == 1
+    assert not any("have been kept" in message for message in log.messages)
 
 
 @pytest.mark.parametrize("credential", [None, "ordinary-api-key"])

{superqode-2.4.41 → superqode-2.4.42}/tests/test_litellm_gateway.py

@@ -8,6 +8,73 @@ from superqode.providers.gateway.base import GatewayResponse, Message
 from superqode.providers.gateway.litellm_gateway import LiteLLMGateway
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("code", list(LiteLLMGateway._QUOTA_ERROR_HINTS))
+async def test_permanent_quota_errors_are_not_retried(monkeypatch, code):
+    from superqode.providers.gateway.base import RateLimitError
+
+    class ProviderQuotaError(Exception):
+        body = {"error": {"code": code, "type": "insufficient_quota"}}
+
+    class ProviderAuthError(Exception):
+        pass
+
+    error = ProviderQuotaError("API quota unavailable")
+    gateway = LiteLLMGateway()
+    attempts = []
+
+    async def reject(**kwargs):
+        attempts.append(kwargs)
+        raise error
+
+    fake_litellm = SimpleNamespace(
+        acompletion=reject,
+        RateLimitError=ProviderQuotaError,
+        AuthenticationError=ProviderAuthError,
+    )
+    monkeypatch.setattr(gateway, "_get_litellm", lambda: fake_litellm)
+    with pytest.raises(ProviderQuotaError):
+        await gateway._acompletion_with_retry({"model": "openai/gpt-4.1"})
+    assert len(attempts) == 1
+    with pytest.raises(RateLimitError) as caught:
+        gateway._handle_litellm_error(error, "openai", "gpt-4.1")
+    assert caught.value.error_type == code
+    assert code in str(caught.value)
+    assert "Retrying will not restore access" in str(caught.value)
+
+
+def test_quota_detection_handles_adapter_message_and_response_body():
+    gateway = LiteLLMGateway()
+    assert not gateway._is_transient_overload_error(
+        RuntimeError("OpenAIException 429 insufficient_quota")
+    )
+    error = RuntimeError("429")
+    error.response = SimpleNamespace(
+        json=lambda: {"error": {"code": "project_spend_limit_exceeded"}}
+    )
+    assert gateway._quota_error_code(error) == "project_spend_limit_exceeded"
+
+
+@pytest.mark.asyncio
+async def test_temporary_rate_limit_still_retries(monkeypatch):
+    class ProviderRateLimitError(Exception):
+        body = {"error": {"code": "rate_limit_exceeded", "type": "rate_limit_error"}}
+
+    gateway = LiteLLMGateway()
+    attempts = []
+
+    async def transient(**kwargs):
+        attempts.append(kwargs)
+        if len(attempts) == 1:
+            raise ProviderRateLimitError("Too many requests")
+        return "recovered"
+
+    monkeypatch.setattr(gateway, "_get_litellm", lambda: SimpleNamespace(acompletion=transient))
+    monkeypatch.setattr(gateway, "_rate_limit_delay", lambda *args: 0)
+    assert await gateway._acompletion_with_retry({"model": "openai/gpt-4.1"}) == "recovered"
+    assert len(attempts) == 2
+
+
 @pytest.mark.asyncio
 async def test_litellm_completion_skips_optional_proxy_mcp_handler(monkeypatch):
     """Tool calls must not require FastAPI in a standard SuperQode install."""