fix(agents): make librarian failures structured and user-safe

- run_librarian / run_librarian_stream raise AgentError instead of
  returning/yielding error text as normal output; detail stays in logs
- delegate_to_* wrappers now put a curated butler-toned sentence in
  DelegationResult.output on failure and never expose str(e), so
  streaming's error branch is reachable and honest
- _execute_single_delegation propagates success; direct delegation only
  records delegate_to_* as called when the expert actually succeeded
- librarian tools return user-safe messages instead of
  'Error searching: {e}' strings that leaked internal URLs into
  synthesis; coordination stream errors are curated as well
- ruff cleanups (TYPE_CHECKING forward refs, B904, unused locals) in
  the touched files to keep them lint-clean

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/responses/streaming.py

@@ -8,14 +8,22 @@ Handles Server-Sent Events (SSE) streaming with proper event types:
 - response.done
 """
 
-from enum import Enum
-from typing import Literal, AsyncGenerator
-import json
 import time
+from collections.abc import AsyncGenerator
+from enum import Enum
+from typing import TYPE_CHECKING, Literal
 
+from src.agents.registry import ModelRegistry
+from src.core.logging_config import get_logger
 from src.core.models import CustomBaseModel
 from src.responses.schemas import Response
-from src.agents.registry import ModelRegistry
+
+if TYPE_CHECKING:
+    from src.agents.steward.schemas import StewardRecommendation
+    from src.core.tool_tracking import ToolCallTracker
+    from src.responses.schemas import ResponseRequest
+
+logger = get_logger(__name__)
 
 
 # ============================================================================
@@ -131,18 +139,17 @@ class StreamingCoordinator:
         Yields:
             StreamEvent: Stream of SSE events
         """
-        from src.responses.service import (
-            _calculate_usage,
-            generate_id,
-            _conversation_history,
-            _direct_delegation_with_results,
-        )
+        import asyncio
+
+        from src.agents.tatlock import TatlockAgent
         from src.core.preprocessing import preprocess_request
         from src.core.tool_tracking import ToolCallTracker
-        from src.responses.schemas import MessageOutputItem, ReasoningOutputItem, OutputTextContent
-        from src.agents.tatlock import TatlockAgent
-        from src.agents.delegation import get_think_message, STREAMING_DELEGATION_WRAPPERS
-        import asyncio
+        from src.responses.schemas import MessageOutputItem, OutputTextContent
+        from src.responses.service import (
+            _calculate_usage,
+            _conversation_history,
+            generate_id,
+        )
 
         output_items = []
 
@@ -280,13 +287,14 @@ class StreamingCoordinator:
         Returns:
             dict: Orchestration results with think_messages list
         """
+        import time as time_module
+
         from src.agents.delegation import (
-            get_think_message,
-            delegate_to_librarian,
             delegate_to_biographer,
             delegate_to_housekeeper,
+            delegate_to_librarian,
+            get_think_message,
         )
-        import time as time_module
 
         expert_results = {}
         tools_called = []
@@ -319,15 +327,26 @@ class StreamingCoordinator:
                     success_msg = get_think_message(agent, user_message, "success")
                     think_messages.append(success_msg + "\n")
                 else:
-                    error_msg = result.error if result else "Unknown error"
-                    expert_results[agent] = f"Error: {error_msg}"
-                    # Emit error think message
+                    # Failed delegations carry a curated user-safe sentence
+                    # in output; exception detail is already in the logs.
                     error_think = get_think_message(agent, user_message, "error")
+                    if result and result.output:
+                        expert_results[agent] = result.output
+                    else:
+                        expert_results[agent] = error_think
+                    # Emit error think message
                     think_messages.append(error_think + "\n")
 
             except Exception as e:
-                expert_results[agent] = f"Error: {e}"
+                logger.error(
+                    "direct_delegation_stream_error",
+                    agent=agent,
+                    error=str(e),
+                    conversation_id=conversation_id,
+                    exc_info=True,
+                )
                 error_think = get_think_message(agent, user_message, "error")
+                expert_results[agent] = error_think
                 think_messages.append(error_think + "\n")
 
         return {
@@ -361,9 +380,10 @@ class StreamingCoordinator:
             event: response.done
             data: {"response": {...}}
         """
-        from src.responses.service import _calculate_usage, generate_id
         import asyncio
 
+        from src.responses.service import _calculate_usage, generate_id
+
         output_items = []
         last_message_text = ""  # Track last streamed message text to compute deltas
 
@@ -488,10 +508,10 @@ class StreamingCoordinator:
     def _convert_output_items(self, items: list) -> list:
         """Convert agent OutputItem objects to schema OutputItem objects."""
         from src.responses.schemas import (
-            MessageOutputItem,
-            ReasoningOutputItem,
             FunctionCallOutputItem,
+            MessageOutputItem,
             OutputTextContent,
+            ReasoningOutputItem,
         )
 
         converted = []
@@ -521,9 +541,9 @@ class StreamingCoordinator:
     def _create_error_event(self, error: Exception) -> ErrorEvent:
         """Create error event from exception."""
         from src.core.exceptions import (
-            RateLimitError,
-            ContextLengthError,
             AppException,
+            ContextLengthError,
+            RateLimitError,
         )
 
         if isinstance(error, RateLimitError):