feat: add minimal feedback collection tool

- Add feedback tool that sends data to API endpoint
- No LangSmith integration - just API calls
- Simple validation with Pydantic
- Auto-included in StackOneToolSet
- 6 focused tests covering validation, execution, and integration

Author: NicolasBelissent

stackone_ai/feedback/__init__.py

@@ -1,4 +1,4 @@
-"""Feedback collection tool for StackOne."""
+"""Feedback collection tools for StackOne."""
 
 from .tool import create_feedback_tool
 

stackone_ai/feedback/tool.py

@@ -46,15 +46,12 @@ def validate_tool_names(cls, v: list[str]) -> list[str]:
 class FeedbackTool(StackOneTool):
     """Extended tool for collecting feedback with enhanced validation."""
 
-    def execute(
-        self, arguments: str | JsonDict | None = None, *, options: JsonDict | None = None
-    ) -> JsonDict:
+    def execute(self, arguments: str | JsonDict | None = None) -> JsonDict:
         """
         Execute the feedback tool with enhanced validation.
 
         Args:
             arguments: Tool arguments as string or dict
-            options: Execution options
 
         Returns:
             Response from the API
@@ -80,7 +77,7 @@ def execute(
             }
 
             # Use the parent execute method with validated arguments
-            return super().execute(validated_arguments, options=options)
+            return super().execute(validated_arguments)
 
         except json.JSONDecodeError as exc:
             raise StackOneError(f"Invalid JSON in arguments: {exc}") from exc

stackone_ai/toolset.py

@@ -7,7 +7,6 @@
 from typing import Any
 
 from stackone_ai.constants import OAS_DIR
-from stackone_ai.feedback import create_feedback_tool
 from stackone_ai.models import (
     StackOneTool,
     Tools,
@@ -172,6 +171,7 @@ def get_tools(
                         all_tools.append(tool)
 
             # Add feedback collection meta tool
+            from .feedback import create_feedback_tool
             feedback_tool_name = "meta_collect_tool_feedback"
             if filter_pattern is None or self._matches_filter(feedback_tool_name, filter_pattern):
                 feedback_tool = create_feedback_tool(

tests/test_feedback.py

@@ -1,4 +1,4 @@
-"""Comprehensive tests for feedback tool."""
+"""Tests for feedback tool."""
 
 # TODO: Remove when Python 3.9 support is dropped
 from __future__ import annotations
@@ -10,25 +10,10 @@
 
 import pytest
 
-# Disable implicit feedback for tests BEFORE importing anything else
-os.environ["STACKONE_IMPLICIT_FEEDBACK_ENABLED"] = "false"
-os.environ.pop("LANGSMITH_API_KEY", None)  # Make sure no Langsmith key is set
-
 from stackone_ai.feedback import create_feedback_tool
 from stackone_ai.models import StackOneError
 
 
-# Mock the implicit feedback manager globally for tests
-@pytest.fixture(autouse=True)
-def mock_implicit_feedback() -> Any:
-    """Mock implicit feedback manager to avoid Langsmith initialization."""
-    with patch("stackone_ai.implicit_feedback.get_implicit_feedback_manager") as mock_manager:
-        mock_instance = Mock()
-        mock_instance.record_tool_call = Mock()
-        mock_manager.return_value = mock_instance
-        yield mock_manager
-
-
 class TestFeedbackToolValidation:
     """Test suite for feedback tool input validation."""
 
@@ -197,33 +182,6 @@ def test_feedback_tool_integration(self) -> None:
             assert langchain_tool.name == "meta_collect_tool_feedback"
             assert "feedback" in langchain_tool.description.lower()
 
-    def test_feedback_tool_smoke(self) -> None:
-        """Lightweight smoke test for basic functionality."""
-        tool = create_feedback_tool(api_key="test_key")
-
-        api_response = {
-            "message": "Feedback successfully stored",
-            "trace_id": "trace-123",
-        }
-
-        with patch("requests.request") as mock_request:
-            mock_response = Mock()
-            mock_response.status_code = 200
-            mock_response.json.return_value = api_response
-            mock_response.raise_for_status = Mock()
-            mock_request.return_value = mock_response
-
-            result = tool.execute(
-                {
-                    "feedback": "Great tools!",
-                    "account_id": "acc_123456",
-                    "tool_names": ["test_tool"],
-                }
-            )
-
-            assert result == api_response
-            mock_request.assert_called_once()
-
 
 @pytest.mark.integration
 def test_live_feedback_submission() -> None:
@@ -255,92 +213,3 @@ def test_live_feedback_submission() -> None:
     assert isinstance(result, dict)
     assert result.get("message", "").lower().startswith("feedback")
     assert "trace_id" in result and result["trace_id"]
-
-
-def test_implicit_feedback_integration() -> None:
-    """Test implicit feedback system integration."""
-    from datetime import datetime, timedelta, timezone
-
-    from stackone_ai.implicit_feedback import (
-        BehaviorAnalyzer,
-        ImplicitFeedbackManager,
-        SessionTracker,
-    )
-
-    class StubLangsmithClient:
-        def __init__(self) -> None:
-            self.is_ready = True
-            self.runs: list[dict[str, object]] = []
-            self.feedback: list[dict[str, object]] = []
-
-        def create_run(self, **kwargs: object) -> dict[str, object]:
-            self.runs.append(kwargs)
-            return {"id": f"run-{len(self.runs)}"}
-
-        def create_feedback(
-            self,
-            *,
-            run_id: str,
-            key: str,
-            score: float | None = None,
-            comment: str | None = None,
-            metadata: dict[str, object] | None = None,
-        ) -> None:
-            self.feedback.append(
-                {
-                    "run_id": run_id,
-                    "key": key,
-                    "score": score,
-                    "comment": comment,
-                    "metadata": metadata,
-                }
-            )
-
-    analyzer = BehaviorAnalyzer()
-    tracker = SessionTracker(analyzer)
-    client = StubLangsmithClient()
-
-    manager = ImplicitFeedbackManager(
-        enabled=True,
-        session_tracker=tracker,
-        langsmith_client=client,  # type: ignore[arg-type]
-    )
-
-    start = datetime.now(timezone.utc)
-    first_end = start + timedelta(seconds=2)
-    manager.record_tool_call(
-        tool_name="crm.search",
-        start_time=start,
-        end_time=first_end,
-        status="success",
-        params={"query": "alpha"},
-        result={"count": 1},
-        error=None,
-        session_id="session-1",
-        user_id="user-1",
-        metadata={"source": "test"},
-        fire_and_forget=False,
-    )
-
-    second_start = first_end + timedelta(seconds=3)
-    manager.record_tool_call(
-        tool_name="crm.search",
-        start_time=second_start,
-        end_time=second_start + timedelta(seconds=1),
-        status="success",
-        params={"query": "alpha"},
-        result={"count": 0},
-        error=None,
-        session_id="session-1",
-        user_id="user-1",
-        metadata={"source": "test"},
-        fire_and_forget=False,
-    )
-
-    assert len(client.runs) == 2
-    assert client.feedback, "Expected implicit feedback events"
-    feedback_entry = client.feedback[0]
-    assert feedback_entry["key"] == "refinement_needed"
-    assert feedback_entry["run_id"] == "run-2"
-    assert isinstance(feedback_entry["metadata"], dict)
-    assert feedback_entry["metadata"].get("tool_name") == "crm.search"