appkit-assistant 0.17.3__py3-none-any.whl → 1.0.0__py3-none-any.whl

appkit_assistant/backend/processors/claude_responses_processor.py

@@ -13,23 +13,25 @@ from collections.abc import AsyncGenerator
 from pathlib import Path
 from typing import Any, Final
 
-import reflex as rx
+from anthropic import AsyncAnthropic
 
-from appkit_assistant.backend.mcp_auth_service import MCPAuthService
-from appkit_assistant.backend.models import (
+from appkit_assistant.backend.database.models import (
+    MCPServer,
+)
+from appkit_assistant.backend.processors.mcp_mixin import MCPCapabilities
+from appkit_assistant.backend.processors.processor_base import mcp_oauth_redirect_uri
+from appkit_assistant.backend.processors.streaming_base import StreamingProcessorBase
+from appkit_assistant.backend.schemas import (
     AIModel,
-    AssistantMCPUserToken,
     Chunk,
     ChunkType,
     MCPAuthType,
-    MCPServer,
     Message,
     MessageType,
 )
-from appkit_assistant.backend.processor import mcp_oauth_redirect_uri
-from appkit_assistant.backend.processors.claude_base import BaseClaudeProcessor
-from appkit_assistant.backend.system_prompt_cache import get_system_prompt
-from appkit_commons.database.session import get_session_manager
+from appkit_assistant.backend.services.citation_handler import ClaudeCitationHandler
+from appkit_assistant.backend.services.file_validation import FileValidationService
+from appkit_assistant.backend.services.system_prompt_builder import SystemPromptBuilder
 
 logger = logging.getLogger(__name__)
 default_oauth_redirect_uri: Final[str] = mcp_oauth_redirect_uri()
@@ -38,8 +40,11 @@ default_oauth_redirect_uri: Final[str] = mcp_oauth_redirect_uri()
 MCP_BETA_HEADER: Final[str] = "mcp-client-2025-11-20"
 FILES_BETA_HEADER: Final[str] = "files-api-2025-04-14"
 
+# Extended thinking budget (fixed at 10k tokens)
+THINKING_BUDGET_TOKENS: Final[int] = 10000
+
 
-class ClaudeResponsesProcessor(BaseClaudeProcessor):
+class ClaudeResponsesProcessor(StreamingProcessorBase, MCPCapabilities):
     """Claude processor using the Messages API with MCP tools and file uploads."""
 
     def __init__(
@@ -49,18 +54,41 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
         base_url: str | None = None,
         oauth_redirect_uri: str = default_oauth_redirect_uri,
     ) -> None:
-        super().__init__(models, api_key, base_url)
-        self._current_reasoning_session: str | None = None
-        self._current_user_id: int | None = None
-        self._mcp_auth_service = MCPAuthService(redirect_uri=oauth_redirect_uri)
-        self._pending_auth_servers: list[MCPServer] = []
+        StreamingProcessorBase.__init__(self, models, "claude_responses")
+        MCPCapabilities.__init__(self, oauth_redirect_uri, "claude_responses")
+
+        self.api_key = api_key
+        self.base_url = base_url
+        self.client: AsyncAnthropic | None = None
+
+        if self.api_key:
+            if self.base_url:
+                self.client = AsyncAnthropic(
+                    api_key=self.api_key,
+                    base_url=self.base_url,
+                )
+            else:
+                self.client = AsyncAnthropic(api_key=self.api_key)
+        else:
+            logger.warning("No Claude API key found. Processor will not work.")
+
+        # Services
+        self._file_validator = FileValidationService()
+        self._citation_handler = ClaudeCitationHandler()
+        self._system_prompt_builder = SystemPromptBuilder()
+
+        # State
         self._uploaded_file_ids: list[str] = []
-        # Track current tool context for streaming
         self._current_tool_context: dict[str, Any] | None = None
-        # Track if we need a newline before next text block
         self._needs_text_separator: bool = False
+        # Tool name tracking: tool_id -> (tool_name, server_label)
+        self._tool_name_map: dict[str, tuple[str, str | None]] = {}
+        # Warnings to display to the user (e.g. disabled tools)
+        self._mcp_warnings: list[str] = []
 
-        logger.debug("Using redirect URI for MCP OAuth: %s", oauth_redirect_uri)
+    def get_supported_models(self) -> dict[str, AIModel]:
+        """Return supported models if API key is available."""
+        return self.models if self.api_key else {}
 
     async def process(
         self,
@@ -81,9 +109,11 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
             raise ValueError(msg)
 
         model = self.models[model_id]
-        self._current_user_id = user_id
-        self._pending_auth_servers = []
+        self.current_user_id = user_id
+        self.clear_pending_auth_servers()
         self._uploaded_file_ids = []
+        self._tool_name_map.clear()  # Clear tool tracking for new request
+        self._mcp_warnings = []  # Clear warnings for new request
 
         try:
             # Upload files if provided
@@ -101,6 +131,11 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
                 file_content_blocks,
             )
 
+            # Yield warnings if any (e.g. disabled tools)
+            if self._mcp_warnings:
+                for warning in self._mcp_warnings:
+                    yield self.chunk_factory.text(f"⚠️ {warning}\n\n")
+
             try:
                 # Process streaming events
                 async with stream as response:
@@ -116,37 +151,26 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
                 logger.error("Error during Claude response processing: %s", error_msg)
                 # Only yield error chunk if NOT an auth error
                 is_auth_related = (
-                    self._is_auth_error(error_msg) or self._pending_auth_servers
+                    self.auth_detector.is_auth_error(error_msg)
+                    or self.pending_auth_servers
                 )
                 if not is_auth_related:
-                    yield Chunk(
-                        type=ChunkType.ERROR,
-                        text=f"Ein Fehler ist aufgetreten: {error_msg}",
-                        chunk_metadata={
-                            "source": "claude_api",
-                            "error_type": type(e).__name__,
-                        },
+                    yield self.chunk_factory.error(
+                        f"Ein Fehler ist aufgetreten: {error_msg}",
+                        error_type=type(e).__name__,
                     )
 
             # Yield any pending auth requirements
-            logger.debug(
-                "Processing pending auth servers: %d", len(self._pending_auth_servers)
-            )
-            for server in self._pending_auth_servers:
-                logger.debug("Yielding auth chunk for server: %s", server.name)
-                yield await self._create_auth_required_chunk(server)
+            async for auth_chunk in self.yield_pending_auth_chunks():
+                yield auth_chunk
 
         except Exception as e:
             logger.error("Critical error in Claude processor: %s", e)
             raise
 
-    def _handle_event(self, event: Any) -> Chunk | None:
-        """Handle streaming events from Claude API."""
-        event_type = getattr(event, "type", None)
-        if not event_type:
-            return None
-
-        handlers = {
+    def _get_event_handlers(self) -> dict[str, Any]:
+        """Get the event handler mapping for Claude API events."""
+        return {
             "message_start": self._handle_message_start,
             "message_delta": self._handle_message_delta,
             "message_stop": self._handle_message_stop,
@@ -155,41 +179,25 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
             "content_block_stop": self._handle_content_block_stop,
         }
 
-        handler = handlers.get(event_type)
-        if handler:
-            return handler(event)
-
-        logger.debug("Unhandled Claude event type: %s", event_type)
-        return None
-
-    def _handle_message_start(self, event: Any) -> Chunk | None:  # noqa: ARG002
+    def _handle_message_start(self, _: Any) -> Chunk | None:
         """Handle message_start event."""
-        return self._create_chunk(
-            ChunkType.LIFECYCLE,
-            "created",
-            {"stage": "created"},
-        )
+        return self.chunk_factory.lifecycle("created", {"stage": "created"})
 
     def _handle_message_delta(self, event: Any) -> Chunk | None:
         """Handle message_delta event (contains stop_reason)."""
         delta = getattr(event, "delta", None)
-        if delta:
-            stop_reason = getattr(delta, "stop_reason", None)
-            if stop_reason:
-                return self._create_chunk(
-                    ChunkType.LIFECYCLE,
-                    f"stop_reason: {stop_reason}",
-                    {"stop_reason": stop_reason},
-                )
-        return None
+        if not delta:
+            return None
+        stop_reason = getattr(delta, "stop_reason", None)
+        if not stop_reason:
+            return None
+        return self.chunk_factory.lifecycle(
+            f"stop_reason: {stop_reason}", {"stop_reason": stop_reason}
+        )
 
-    def _handle_message_stop(self, event: Any) -> Chunk | None:  # noqa: ARG002
+    def _handle_message_stop(self, _: Any) -> Chunk | None:
         """Handle message_stop event."""
-        return self._create_chunk(
-            ChunkType.COMPLETION,
-            "Response generation completed",
-            {"status": "response_complete"},
-        )
+        return self.chunk_factory.completion(status="response_complete")
 
     def _handle_content_block_start(self, event: Any) -> Chunk | None:
         """Handle content_block_start event."""
@@ -214,42 +222,52 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
 
         return None
 
-    def _handle_text_block_start(self, content_block: Any) -> Chunk | None:  # noqa: ARG002
+    def _handle_text_block_start(self, _: Any) -> Chunk | None:
         """Handle start of text content block."""
-        if self._needs_text_separator:
-            self._needs_text_separator = False
-            return self._create_chunk(ChunkType.TEXT, "\n\n", {"separator": "true"})
-        return None
+        if not self._needs_text_separator:
+            return None
+        self._needs_text_separator = False
+        return self.chunk_factory.text("\n\n", {"separator": "true"})
 
     def _handle_thinking_block_start(self, content_block: Any) -> Chunk:
         """Handle start of thinking content block."""
         thinking_id = getattr(content_block, "id", "thinking")
-        self._current_reasoning_session = thinking_id
+        self.current_reasoning_session = thinking_id
         self._needs_text_separator = True
-        return self._create_chunk(
-            ChunkType.THINKING,
-            "Denke nach...",
-            {"reasoning_id": thinking_id, "status": "starting"},
+        return self.chunk_factory.thinking(
+            "Denke nach...", reasoning_id=thinking_id, status="starting"
         )
 
-    def _handle_tool_use_block_start(self, content_block: Any) -> Chunk:
-        """Handle start of tool_use content block."""
-        tool_name = getattr(content_block, "name", "unknown_tool")
-        tool_id = getattr(content_block, "id", "unknown_id")
+    def _handle_tool_use_common(
+        self,
+        tool_name: str,
+        tool_id: str,
+        server_label: str | None,
+        tool_display_name: str,
+    ) -> Chunk:
+        """Common handler for tool use start."""
         self._current_tool_context = {
             "tool_name": tool_name,
             "tool_id": tool_id,
-            "server_label": None,
+            "server_label": server_label,
         }
-        return self._create_chunk(
-            ChunkType.TOOL_CALL,
-            f"Benutze Werkzeug: {tool_name}",
-            {
-                "tool_name": tool_name,
-                "tool_id": tool_id,
-                "status": "starting",
-                "reasoning_session": self._current_reasoning_session,
-            },
+        # Store for result lookup
+        self._tool_name_map[tool_id] = (tool_name, server_label)
+        return self.chunk_factory.tool_call(
+            tool_display_name,
+            tool_name=tool_name,
+            tool_id=tool_id,
+            server_label=server_label,
+            status="starting",
+            reasoning_session=self.current_reasoning_session,
+        )
+
+    def _handle_tool_use_block_start(self, content_block: Any) -> Chunk:
+        """Handle start of tool_use content block."""
+        tool_name = getattr(content_block, "name", "unknown_tool")
+        tool_id = getattr(content_block, "id", "unknown_id")
+        return self._handle_tool_use_common(
+            tool_name, tool_id, None, f"Benutze Werkzeug: {tool_name}"
         )
 
     def _handle_mcp_tool_use_block_start(self, content_block: Any) -> Chunk:
@@ -257,21 +275,11 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
         tool_name = getattr(content_block, "name", "unknown_tool")
         tool_id = getattr(content_block, "id", "unknown_id")
         server_name = getattr(content_block, "server_name", "unknown_server")
-        self._current_tool_context = {
-            "tool_name": tool_name,
-            "tool_id": tool_id,
-            "server_label": server_name,
-        }
-        return self._create_chunk(
-            ChunkType.TOOL_CALL,
+        return self._handle_tool_use_common(
+            tool_name,
+            tool_id,
+            server_name,
             f"Benutze Werkzeug: {server_name}.{tool_name}",
-            {
-                "tool_name": tool_name,
-                "tool_id": tool_id,
-                "server_label": server_name,
-                "status": "starting",
-                "reasoning_session": self._current_reasoning_session,
-            },
         )
 
     def _handle_mcp_tool_result_block_start(self, content_block: Any) -> Chunk:
@@ -281,41 +289,43 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
         is_error = bool(getattr(content_block, "is_error", False))
         content = getattr(content_block, "content", "")
 
+        # Look up tool name and server from map
+        tool_info = self._tool_name_map.get(tool_use_id, ("unknown_tool", None))
+        tool_name, server_label = tool_info
+
         logger.debug(
-            "MCP tool result - tool_use_id: %s, is_error: %s, content type: %s",
+            "MCP tool result - tool_use_id: %s, tool: %s, server: %s, is_error: %s",
             tool_use_id,
+            tool_name,
+            server_label,
             is_error,
-            type(content).__name__,
         )
 
         result_text = self._extract_mcp_result_text(content)
         status = "error" if is_error else "completed"
-        return self._create_chunk(
-            ChunkType.TOOL_RESULT,
+        return self.chunk_factory.tool_result(
             result_text or ("Werkzeugfehler" if is_error else "Erfolgreich"),
-            {
-                "tool_id": tool_use_id,
-                "status": status,
-                "error": is_error,
-                "reasoning_session": self._current_reasoning_session,
-            },
+            tool_id=tool_use_id,
+            tool_name=tool_name,
+            server_label=server_label,
+            status=status,
+            is_error=is_error,
+            reasoning_session=self.current_reasoning_session,
         )
 
     def _extract_mcp_result_text(self, content: Any) -> str:
         """Extract text from MCP tool result content."""
-        if isinstance(content, list):
-            parts = []
-            for item in content:
-                if isinstance(item, dict):
-                    parts.append(item.get("text", str(item)))
-                elif hasattr(item, "text"):
-                    parts.append(getattr(item, "text", str(item)))
-                else:
-                    parts.append(str(item))
-            return "".join(parts)
-        return str(content) if content else ""
-
-        return None
+        if not content:
+            return ""
+        if not isinstance(content, list):
+            return str(content)
+        parts = []
+        for item in content:
+            if isinstance(item, dict):
+                parts.append(item.get("text", str(item)))
+            else:
+                parts.append(getattr(item, "text", str(item)))
+        return "".join(parts)
 
     def _handle_content_block_delta(self, event: Any) -> Chunk | None:
         """Handle content_block_delta event."""
@@ -327,159 +337,70 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
 
         if delta_type == "text_delta":
             text = getattr(delta, "text", "")
-            # Extract citations from text if present
-            citations = self._extract_citations_from_delta(delta)
-            metadata = {"delta": text}
+            # Extract citations using the citation handler
+            citations = self._citation_handler.extract_citations(delta)
+            metadata: dict[str, Any] = {"delta": text}
             if citations:
-                metadata["citations"] = json.dumps(citations)
-            return self._create_chunk(ChunkType.TEXT, text, metadata)
+                metadata["citations"] = json.dumps(
+                    [self._citation_handler.to_dict(c) for c in citations]
+                )
+            return self.chunk_factory.text(text, metadata)
 
         if delta_type == "thinking_delta":
             thinking_text = getattr(delta, "thinking", "")
-            return self._create_chunk(
-                ChunkType.THINKING,
+            return self.chunk_factory.thinking(
                 thinking_text,
-                {
-                    "reasoning_id": self._current_reasoning_session,
-                    "status": "in_progress",
-                    "delta": thinking_text,
-                },
+                reasoning_id=self.current_reasoning_session,
+                status="in_progress",
+                delta=thinking_text,
             )
 
         if delta_type == "input_json_delta":
             partial_json = getattr(delta, "partial_json", "")
             # Include tool context in streaming chunks
-            metadata: dict[str, Any] = {
-                "status": "arguments_streaming",
-                "delta": partial_json,
-                "reasoning_session": self._current_reasoning_session,
-            }
+            tool_name = "unknown_tool"
+            tool_id = "unknown_id"
+            server_label = None
             if self._current_tool_context:
-                metadata["tool_name"] = self._current_tool_context.get("tool_name")
-                metadata["tool_id"] = self._current_tool_context.get("tool_id")
-                if self._current_tool_context.get("server_label"):
-                    metadata["server_label"] = self._current_tool_context[
-                        "server_label"
-                    ]
-            return self._create_chunk(
-                ChunkType.TOOL_CALL,
+                tool_name = self._current_tool_context.get("tool_name", "unknown_tool")
+                tool_id = self._current_tool_context.get("tool_id", "unknown_id")
+                server_label = self._current_tool_context.get("server_label")
+            return self.chunk_factory.tool_call(
                 partial_json,
-                metadata,
+                tool_name=tool_name,
+                tool_id=tool_id,
+                server_label=server_label,
+                status="arguments_streaming",
+                reasoning_session=self.current_reasoning_session,
             )
 
+        logger.debug("Unhandled delta type in stream: %s", delta_type)
         return None
 
-    def _handle_content_block_stop(self, event: Any) -> Chunk | None:  # noqa: ARG002
+    def _handle_content_block_stop(self, _: Any) -> Chunk | None:
         """Handle content_block_stop event."""
-        # Check if this was a thinking block ending
-        if self._current_reasoning_session:
-            # Reset reasoning session after thinking completes
-            reasoning_id = self._current_reasoning_session
-            self._current_reasoning_session = None
-            return self._create_chunk(
+        if self.current_reasoning_session:
+            reasoning_id = self.current_reasoning_session
+            self.current_reasoning_session = None
+            return self.chunk_factory.create(
                 ChunkType.THINKING_RESULT,
                 "beendet.",
                 {"reasoning_id": reasoning_id, "status": "completed"},
             )
 
-        # Check if this was a tool block ending
         if self._current_tool_context:
-            tool_context = self._current_tool_context
+            ctx = self._current_tool_context
             self._current_tool_context = None
-            metadata: dict[str, Any] = {
-                "tool_name": tool_context.get("tool_name"),
-                "tool_id": tool_context.get("tool_id"),
-                "status": "arguments_complete",
-            }
-            if tool_context.get("server_label"):
-                metadata["server_label"] = tool_context["server_label"]
-            return self._create_chunk(
-                ChunkType.TOOL_CALL,
+            return self.chunk_factory.tool_call(
                 "Werkzeugargumente vollständig",
-                metadata,
+                tool_name=ctx.get("tool_name"),
+                tool_id=ctx.get("tool_id"),
+                server_label=ctx.get("server_label"),
+                status="arguments_complete",
             )
 
         return None
 
-    def _extract_citations_from_delta(self, delta: Any) -> list[dict[str, Any]]:
-        """Extract citation information from a text delta."""
-        citations = []
-
-        # Claude provides citations in the text block's citations field
-        text_block_citations = getattr(delta, "citations", None)
-        if text_block_citations:
-            for citation in text_block_citations:
-                citation_data = {
-                    "cited_text": getattr(citation, "cited_text", ""),
-                    "document_index": getattr(citation, "document_index", 0),
-                    "document_title": getattr(citation, "document_title", None),
-                }
-
-                # Handle different citation location types
-                citation_type = getattr(citation, "type", None)
-                if citation_type == "char_location":
-                    citation_data["start_char_index"] = getattr(
-                        citation, "start_char_index", 0
-                    )
-                    citation_data["end_char_index"] = getattr(
-                        citation, "end_char_index", 0
-                    )
-                elif citation_type == "page_location":
-                    citation_data["start_page_number"] = getattr(
-                        citation, "start_page_number", 0
-                    )
-                    citation_data["end_page_number"] = getattr(
-                        citation, "end_page_number", 0
-                    )
-                elif citation_type == "content_block_location":
-                    citation_data["start_block_index"] = getattr(
-                        citation, "start_block_index", 0
-                    )
-                    citation_data["end_block_index"] = getattr(
-                        citation, "end_block_index", 0
-                    )
-
-                citations.append(citation_data)
-
-        return citations
-
-    def _is_auth_error(self, error: Any) -> bool:
-        """Check if an error indicates authentication failure (401/403)."""
-        error_str = str(error).lower()
-        auth_indicators = [
-            "401",
-            "403",
-            "unauthorized",
-            "forbidden",
-            "authentication required",
-            "access denied",
-            "invalid token",
-            "token expired",
-        ]
-        return any(indicator in error_str for indicator in auth_indicators)
-
-    def _create_chunk(
-        self,
-        chunk_type: ChunkType,
-        content: str,
-        extra_metadata: dict[str, Any] | None = None,
-    ) -> Chunk:
-        """Create a Chunk with content from the event."""
-        metadata: dict[str, str] = {
-            "processor": "claude_responses",
-        }
-
-        if extra_metadata:
-            for key, value in extra_metadata.items():
-                if value is not None:
-                    metadata[key] = str(value)
-
-        return Chunk(
-            type=chunk_type,
-            text=content,
-            chunk_metadata=metadata,
-        )
-
     async def _process_files(self, files: list[str]) -> list[dict[str, Any]]:
         """Process and upload files for use in messages.
 
@@ -492,7 +413,7 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
         content_blocks = []
 
         for file_path in files:
-            is_valid, error_msg = self._validate_file(file_path)
+            is_valid, error_msg = self._file_validator.validate_file(file_path)
             if not is_valid:
                 logger.warning("Skipping invalid file %s: %s", file_path, error_msg)
                 continue
@@ -530,9 +451,9 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
         # Read file content
         file_data = path.read_bytes()
 
-        media_type = self._get_media_type(file_path)
+        media_type = self._file_validator.get_media_type(file_path)
 
-        if self._is_image_file(file_path):
+        if self._file_validator.is_image_file(file_path):
             # For images, use base64 encoding directly in the message
             base64_data = base64.standard_b64encode(file_data).decode("utf-8")
             return {
@@ -595,7 +516,7 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
         )
 
         # Build system prompt
-        system_prompt = await self._build_system_prompt(mcp_prompt)
+        system_prompt = await self._system_prompt_builder.build(mcp_prompt)
 
         # Determine which beta features to enable
         betas = []
@@ -627,16 +548,20 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
         # Add extended thinking (always enabled with fixed budget)
         params["thinking"] = {
             "type": "enabled",
-            "budget_tokens": self.THINKING_BUDGET_TOKENS,
+            "budget_tokens": THINKING_BUDGET_TOKENS,
         }
 
         # Add temperature
         if model.temperature is not None:
             params["temperature"] = model.temperature
 
-        # Merge any additional payload
+        # Merge any additional payload (excluding internal keys)
         if payload:
-            params.update(payload)
+            internal_keys = {"thread_uuid"}
+            filtered_payload = {
+                k: v for k, v in payload.items() if k not in internal_keys
+            }
+            params.update(filtered_payload)
 
         # Create streaming request
         if betas:
@@ -736,11 +661,16 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
             # Parse headers to get auth token and query params
             auth_token, query_suffix = self._parse_mcp_headers(server)
 
-            # Build URL with query params if needed
-            server_url = server.url
+            # Check if tool requires unsupported headers (converted to query suffix).
+            # Claude currently does not support custom headers for MCP servers.
             if query_suffix:
-                separator = "&" if "?" in server_url else "?"
-                server_url = f"{server_url}{separator}{query_suffix}"
+                warning_msg = (
+                    f"Der MCP-Server '{server.name}' wurde deaktiviert, "
+                    "da er HTTP-Header benötigt, die von der Claude API "
+                    "nicht unterstützt werden."
+                )
+                self._mcp_warnings.append(warning_msg)
+                continue
 
             # Build MCP server configuration
             server_config: dict[str, Any] = {
@@ -753,20 +683,20 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
 
             # Inject OAuth token if required (overrides static header token)
             if server.auth_type == MCPAuthType.OAUTH_DISCOVERY and user_id is not None:
-                token = await self._get_valid_token_for_server(server, user_id)
+                token = await self.get_valid_token(server, user_id)
                 if token:
                     server_config["authorization_token"] = token.access_token
                     logger.debug("Injected OAuth token for server %s", server.name)
                 else:
                     # Track for potential auth flow
-                    self._pending_auth_servers.append(server)
+                    self.add_pending_auth_server(server)
                     logger.debug(
                         "No valid token for OAuth server %s, auth may be required",
                         server.name,
                     )
 
-            # Set the final URL (may include query params from headers)
-            server_config["url"] = server_url
+            # Set the final URL
+            server_config["url"] = server.url
             server_configs.append(server_config)
 
             # Add MCP toolset for this server
@@ -789,41 +719,22 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
         messages: list[Message],
         file_content_blocks: list[dict[str, Any]] | None = None,
     ) -> list[dict[str, Any]]:
-        """Convert messages to Claude API format.
-
-        Args:
-            messages: List of conversation messages
-            file_content_blocks: Optional file content blocks to attach
-
-        Returns:
-            List of Claude-formatted messages
-        """
+        """Convert messages to Claude API format."""
         claude_messages = []
+        last_idx = len(messages) - 1
 
         for i, msg in enumerate(messages):
             if msg.type == MessageType.SYSTEM:
-                continue  # System messages handled separately
+                continue
 
             role = "user" if msg.type == MessageType.HUMAN else "assistant"
-
-            # Build content
             content: list[dict[str, Any]] = []
 
-            # For the last user message, attach files if present
-            is_last_user = (
-                role == "user" and i == len(messages) - 1 and file_content_blocks
-            )
-
-            if is_last_user and file_content_blocks:
+            # Attach files to last user message
+            if role == "user" and i == last_idx and file_content_blocks:
                 content.extend(file_content_blocks)
 
-            # Add text content
-            content.append(
-                {
-                    "type": "text",
-                    "text": msg.text,
-                }
-            )
+            content.append({"type": "text", "text": msg.text})
 
             claude_messages.append(
                 {
@@ -833,96 +744,3 @@ class ClaudeResponsesProcessor(BaseClaudeProcessor):
             )
 
         return claude_messages
-
-    async def _build_system_prompt(self, mcp_prompt: str = "") -> str:
-        """Build the system prompt with optional MCP tool descriptions.
-
-        Args:
-            mcp_prompt: Optional MCP tool prompts
-
-        Returns:
-            Complete system prompt string
-        """
-        # Get base system prompt
-        system_prompt_template = await get_system_prompt()
-
-        # Format with MCP prompts
-        if mcp_prompt:
-            mcp_section = (
-                "### Tool-Auswahlrichtlinien (Einbettung externer Beschreibungen)\n"
-                f"{mcp_prompt}"
-            )
-        else:
-            mcp_section = ""
-
-        return system_prompt_template.format(mcp_prompts=mcp_section)
-
-    async def _get_valid_token_for_server(
-        self,
-        server: MCPServer,
-        user_id: int,
-    ) -> AssistantMCPUserToken | None:
-        """Get a valid OAuth token for the given server and user.
-
-        Args:
-            server: The MCP server configuration
-            user_id: The user's ID
-
-        Returns:
-            A valid token or None if not available
-        """
-        if server.id is None:
-            return None
-
-        with rx.session() as session:
-            token = self._mcp_auth_service.get_user_token(session, user_id, server.id)
-
-            if token is None:
-                return None
-
-            return await self._mcp_auth_service.ensure_valid_token(
-                session, server, token
-            )
-
-    async def _create_auth_required_chunk(self, server: MCPServer) -> Chunk:
-        """Create an AUTH_REQUIRED chunk for a server that needs authentication.
-
-        Args:
-            server: The MCP server requiring authentication
-
-        Returns:
-            A chunk signaling auth is required with the auth URL
-        """
-        try:
-            with get_session_manager().session() as session:
-                auth_service = self._mcp_auth_service
-                (
-                    auth_url,
-                    state,
-                ) = await auth_service.build_authorization_url_with_registration(
-                    server,
-                    session=session,
-                    user_id=self._current_user_id,
-                )
-                logger.info(
-                    "Built auth URL for server %s, state=%s, url=%s",
-                    server.name,
-                    state,
-                    auth_url[:100] if auth_url else "None",
-                )
-        except (ValueError, Exception) as e:
-            logger.error("Cannot build auth URL for server %s: %s", server.name, str(e))
-            auth_url = ""
-            state = ""
-
-        return Chunk(
-            type=ChunkType.AUTH_REQUIRED,
-            text=f"{server.name} benötigt Ihre Autorisierung",
-            chunk_metadata={
-                "server_id": str(server.id) if server.id else "",
-                "server_name": server.name,
-                "auth_url": auth_url,
-                "state": state,
-                "processor": "claude_responses",
-            },
-        )