fix(mcp): let original_tool disambiguate a feedback-name collision in prepare_tool_call

On the custom-dispatcher path prepare_tool_list skips injecting the
virtual tool when a real tool owns the feedback name, but prepare_tool_call
still flagged every call by that name as feedback, so the documented
dispatch flow suppressed the real tool. A host-supplied original_tool is
stateless proof a real tool owns the name (the virtual tool never exists
in the host's own list), so it now wins. Without original_tool the name
match stands and the documented remedy is a non-colliding tool_name.

Generated-By: PostHog Desktop
Task-Id: 0b5063cb-6fcf-4364-be5e-de945b1448f0

Author: gesh

posthog/mcp/posthog_mcp.py

@@ -400,7 +400,12 @@ def prepare_tool_call(
         ``send_feedback`` virtual tools (the latter only with the constructor's
         ``collect_feedback`` opt-in, so a real tool by that name is never
         shadowed). When model capture is enabled, resolve its value and source and
-        strip the SDK-owned ``llm_model`` argument before dispatch."""
+        strip the SDK-owned ``llm_model`` argument before dispatch.
+
+        ``original_tool`` is the application's own tool for ``name``, from the
+        host's un-prepared list (the virtual tools never exist there). Passing it
+        also disambiguates a name collision: a real tool by the feedback tool's
+        name is dispatched normally instead of being flagged as feedback."""
         raw_context = (args or {}).get("context")
         intent = (
             raw_context.strip()
@@ -423,8 +428,15 @@ def prepare_tool_call(
         prepared_args = _strip_context(args)
         if analytics_owns_model:
             prepared_args = _strip_model(prepared_args)
+        # A supplied `original_tool` is a real application tool by this name (it
+        # comes from the host's own list, which never holds the virtual tool), so
+        # the real tool wins — the stateless twin of instrument()'s listing-derived
+        # shadow flag. Without it the name match stands, and the documented remedy
+        # for a collision is configuring a non-colliding `tool_name`.
         is_feedback = (
-            self._collect_feedback is not None and name == self._feedback_tool_name
+            self._collect_feedback is not None
+            and name == self._feedback_tool_name
+            and original_tool is None
         )
         return PreparedToolCall(
             args=prepared_args,

posthog/test/mcp/test_feedback.py

@@ -796,6 +796,26 @@ async def test_posthogmcp_prepare_tool_call_without_opt_in_never_flags():
     assert call.is_feedback is False and call.feedback_report is None
 
 
+async def test_posthogmcp_original_tool_wins_name_collision():
+    # A host whose own list holds a real `send_feedback` tool passes it as
+    # `original_tool`; the call then dispatches as a real tool call instead of
+    # being swallowed as feedback — the stateless twin of instrument()'s
+    # listing-derived shadow flag.
+    client, _ = make_client(collect_feedback=True)
+    real_tool = {
+        "name": "send_feedback",
+        "inputSchema": {"type": "object", "properties": {"note": {"type": "string"}}},
+    }
+    call = client.prepare_tool_call(
+        "send_feedback", {"note": "hi"}, original_tool=real_tool
+    )
+    assert call.is_feedback is False and call.feedback_report is None
+
+    # Without `original_tool` the name match stands (TS parity).
+    virtual = client.prepare_tool_call("send_feedback", dict(_REPORT_ARGS))
+    assert virtual.is_feedback is True and virtual.feedback_report is not None
+
+
 async def test_posthogmcp_capture_feedback_event_shape():
     client, captured = make_client(collect_feedback=True)
     call = client.prepare_tool_call("send_feedback", dict(_REPORT_ARGS))