fenix-mcp 0.7.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

fenix_mcp/application/tools/productivity.py

@@ -30,18 +30,18 @@ class TodoAction(str, Enum):
         obj.description = description
         return obj
 
-    CREATE = ("todo_create", "Cria um novo TODO.")
-    LIST = ("todo_list", "Lista TODOs com filtros opcionais.")
-    GET = ("todo_get", "Obtém detalhes de um TODO pelo ID.")
-    UPDATE = ("todo_update", "Atualiza campos de um TODO existente.")
-    DELETE = ("todo_delete", "Remove um TODO pelo ID.")
-    STATS = ("todo_stats", "Retorna estatísticas agregadas de TODOs.")
-    SEARCH = ("todo_search", "Busca TODOs por termo textual.")
-    OVERDUE = ("todo_overdue", "Lista TODOs atrasados.")
-    UPCOMING = ("todo_upcoming", "Lista TODOs com vencimento próximo.")
-    CATEGORIES = ("todo_categories", "Lista categorias registradas.")
-    TAGS = ("todo_tags", "Lista tags registradas.")
-    HELP = ("todo_help", "Mostra as ações suportadas e seus usos.")
+    CREATE = ("todo_create", "Creates a new TODO.")
+    LIST = ("todo_list", "Lists TODOs with optional filters.")
+    GET = ("todo_get", "Gets TODO details by ID.")
+    UPDATE = ("todo_update", "Updates fields of an existing TODO.")
+    DELETE = ("todo_delete", "Removes a TODO by ID.")
+    STATS = ("todo_stats", "Returns aggregated TODO statistics.")
+    SEARCH = ("todo_search", "Searches TODOs by text term.")
+    OVERDUE = ("todo_overdue", "Lists overdue TODOs.")
+    UPCOMING = ("todo_upcoming", "Lists TODOs with upcoming due dates.")
+    CATEGORIES = ("todo_categories", "Lists registered categories.")
+    TAGS = ("todo_tags", "Lists registered tags.")
+    HELP = ("todo_help", "Shows supported actions and their uses.")
 
     @classmethod
     def choices(cls) -> List[str]:
@@ -50,7 +50,7 @@ class TodoAction(str, Enum):
     @classmethod
     def formatted_help(cls) -> str:
         lines = [
-            "| **Ação** | **Descrição** |",
+            "| **Action** | **Description** |",
             "| --- | --- |",
         ]
         for member in cls:
@@ -59,7 +59,7 @@ class TodoAction(str, Enum):
 
 
 ACTION_FIELD_DESCRIPTION = (
-    "Ação de produtividade (TODO). Escolha um dos valores: "
+    "Productivity action (TODO). Choose one of the values: "
     + ", ".join(
         f"`{member.value}` ({member.description.rstrip('.')})." for member in TodoAction
     )
@@ -68,40 +68,40 @@ ACTION_FIELD_DESCRIPTION = (
 
 class ProductivityRequest(ToolRequest):
     action: TodoAction = Field(description=ACTION_FIELD_DESCRIPTION)
-    id: Optional[UUIDStr] = Field(default=None, description="ID do item TODO (UUID).")
+    id: Optional[UUIDStr] = Field(default=None, description="TODO item ID (UUID).")
     title: Optional[TitleStr] = Field(
-        default=None, description="Título do TODO (obrigatório em create)."
+        default=None, description="TODO title (required for create)."
     )
     content: Optional[MarkdownStr] = Field(
-        default=None, description="Conteúdo em Markdown (obrigatório em create)."
+        default=None, description="Markdown content (required for create)."
     )
     status: Optional[str] = Field(
         default=None,
-        description="Status do TODO (pending, in_progress, completed, cancelled).",
+        description="TODO status (pending, in_progress, completed, cancelled).",
     )
     priority: Optional[str] = Field(
-        default=None, description="Prioridade do TODO (low, medium, high, urgent)."
+        default=None, description="TODO priority (low, medium, high, urgent)."
     )
     category: Optional[CategoryStr] = Field(
-        default=None, description="Categoria opcional."
+        default=None, description="Optional category."
     )
-    tags: Optional[List[TagStr]] = Field(default=None, description="Lista de tags.")
+    tags: Optional[List[TagStr]] = Field(default=None, description="Tag list.")
     due_date: Optional[DateTimeStr] = Field(
-        default=None, description="Data de vencimento do TODO (ISO 8601)."
+        default=None, description="TODO due date (ISO 8601)."
     )
     limit: int = Field(
-        default=20, ge=1, le=100, description="Limite de resultados em list/search."
+        default=20, ge=1, le=100, description="Result limit for list/search."
     )
-    offset: int = Field(default=0, ge=0, description="Offset de paginação.")
-    query: Optional[str] = Field(default=None, description="Termo de busca.")
+    offset: int = Field(default=0, ge=0, description="Pagination offset.")
+    query: Optional[str] = Field(default=None, description="Search term.")
     days: Optional[int] = Field(
-        default=None, ge=1, le=30, description="Janela de dias para upcoming."
+        default=None, ge=1, le=30, description="Day window for upcoming."
     )
 
 
 class ProductivityTool(Tool):
     name = "productivity"
-    description = "Operações de produtividade do Fênix Cloud (TODOs)."
+    description = "Fenix Cloud productivity operations (TODOs)."
     request_model = ProductivityRequest
 
     def __init__(self, context: AppContext):
@@ -135,13 +135,13 @@ class ProductivityTool(Tool):
         if action is TodoAction.TAGS:
             return await self._handle_tags()
         return text(
-            "❌ Ação inválida para productivity.\n\nEscolha um dos valores:\n"
+            "❌ Invalid action for productivity.\n\nChoose one of the values:\n"
             + "\n".join(f"- `{value}`" for value in TodoAction.choices())
         )
 
     async def _handle_create(self, payload: ProductivityRequest):
         if not payload.title or not payload.content or not payload.due_date:
-            return text("❌ Forneça título, conteúdo e due_date para criar um TODO.")
+            return text("❌ Provide title, content and due_date to create a TODO.")
         todo = await self._service.create_todo(
             title=payload.title,
             content=payload.content,
@@ -151,7 +151,7 @@ class ProductivityTool(Tool):
             tags=payload.tags or [],
             due_date=payload.due_date,
         )
-        return text(self._format_single(todo, header="✅ TODO criado com sucesso!"))
+        return text(self._format_single(todo, header="✅ TODO created successfully!"))
 
     async def _handle_list(self, payload: ProductivityRequest):
         todos = await self._service.list_todos(
@@ -162,19 +162,19 @@ class ProductivityTool(Tool):
             category=payload.category,
         )
         if not todos:
-            return text("📋 Nenhum TODO encontrado.")
+            return text("📋 No TODOs found.")
         body = "\n\n".join(ProductivityService.format_todo(todo) for todo in todos)
         return text(f"📋 **TODOs ({len(todos)}):**\n\n{body}")
 
     async def _handle_get(self, payload: ProductivityRequest):
         if not payload.id:
-            return text("❌ Informe o ID para consultar um TODO.")
+            return text("❌ Provide the ID to get a TODO.")
         todo = await self._service.get_todo(payload.id)
-        return text(self._format_single(todo, header="📋 TODO encontrado"))
+        return text(self._format_single(todo, header="📋 TODO found"))
 
     async def _handle_update(self, payload: ProductivityRequest):
         if not payload.id:
-            return text("❌ Informe o ID para atualizar um TODO.")
+            return text("❌ Provide the ID to update a TODO.")
         fields = {
             "title": payload.title,
             "content": payload.content,
@@ -185,66 +185,66 @@ class ProductivityTool(Tool):
             "due_date": payload.due_date,
         }
         todo = await self._service.update_todo(payload.id, **fields)
-        return text(self._format_single(todo, header="✅ TODO atualizado"))
+        return text(self._format_single(todo, header="✅ TODO updated"))
 
     async def _handle_delete(self, payload: ProductivityRequest):
         if not payload.id:
-            return text("❌ Informe o ID para excluir um TODO.")
+            return text("❌ Provide the ID to delete a TODO.")
         await self._service.delete_todo(payload.id)
-        return text(f"🗑️ TODO {payload.id} removido com sucesso.")
+        return text(f"🗑️ TODO {payload.id} removed successfully.")
 
     async def _handle_stats(self):
         stats = await self._service.stats()
-        lines = ["📊 **Estatísticas de TODOs**"]
+        lines = ["📊 **TODO Statistics**"]
         for key, value in (stats or {}).items():
             lines.append(f"- {key}: {value}")
         return text("\n".join(lines))
 
     async def _handle_search(self, payload: ProductivityRequest):
         if not payload.query:
-            return text("❌ Informe um termo de busca (query).")
+            return text("❌ Provide a search term (query).")
         todos = await self._service.search(
             payload.query, limit=payload.limit, offset=payload.offset
         )
         if not todos:
-            return text("🔍 Nenhum TODO encontrado para a busca.")
+            return text("🔍 No TODOs found for the search.")
         body = "\n\n".join(ProductivityService.format_todo(todo) for todo in todos)
-        return text(f"🔍 **Resultados da busca ({len(todos)}):**\n\n{body}")
+        return text(f"🔍 **Search results ({len(todos)}):**\n\n{body}")
 
     async def _handle_overdue(self):
         todos = await self._service.overdue()
         if not todos:
-            return text("✅ Sem TODOs atrasados no momento.")
+            return text("✅ No overdue TODOs at the moment.")
         body = "\n\n".join(ProductivityService.format_todo(todo) for todo in todos)
-        return text(f"⏰ **TODOs atrasados ({len(todos)}):**\n\n{body}")
+        return text(f"⏰ **Overdue TODOs ({len(todos)}):**\n\n{body}")
 
     async def _handle_upcoming(self, payload: ProductivityRequest):
         todos = await self._service.upcoming(days=payload.days)
         if not todos:
-            return text("📅 Nenhum TODO previsto para o período informado.")
+            return text("📅 No TODOs scheduled for the specified period.")
         body = "\n\n".join(ProductivityService.format_todo(todo) for todo in todos)
-        header = f"📅 TODOs programados ({len(todos)}):"
+        header = f"📅 Scheduled TODOs ({len(todos)}):"
         if payload.days:
-            header += f" próximos {payload.days} dias"
+            header += f" next {payload.days} days"
         return text(f"{header}\n\n{body}")
 
     async def _handle_categories(self):
         categories = await self._service.categories()
         if not categories:
-            return text("🏷️ Nenhuma categoria registrada ainda.")
+            return text("🏷️ No categories registered yet.")
         body = "\n".join(f"- {category}" for category in categories)
-        return text(f"🏷️ **Categorias utilizadas:**\n{body}")
+        return text(f"🏷️ **Categories in use:**\n{body}")
 
     async def _handle_tags(self):
         tags = await self._service.tags()
         if not tags:
-            return text("🔖 Nenhuma tag registrada ainda.")
+            return text("🔖 No tags registered yet.")
         body = "\n".join(f"- {tag}" for tag in tags)
-        return text(f"🔖 **Tags utilizadas:**\n{body}")
+        return text(f"🔖 **Tags in use:**\n{body}")
 
     async def _handle_help(self):
         return text(
-            "📚 **Ações disponíveis para productivity**\n\n"
+            "📚 **Available actions for productivity**\n\n"
             + TodoAction.formatted_help()
         )
 

fenix_mcp/application/tools/user_config.py

@@ -27,12 +27,12 @@ class UserConfigAction(str, Enum):
         obj.description = description
         return obj
 
-    CREATE = ("create", "Cria um novo user core document.")
-    LIST = ("list", "Lista documentos com paginação opcional.")
-    GET = ("get", "Obtém detalhes de um documento específico.")
-    UPDATE = ("update", "Atualiza campos de um documento existente.")
-    DELETE = ("delete", "Remove um documento.")
-    HELP = ("help", "Mostra as ações disponíveis e seus usos.")
+    CREATE = ("create", "Creates a new user core document.")
+    LIST = ("list", "Lists documents with optional pagination.")
+    GET = ("get", "Gets details of a specific document.")
+    UPDATE = ("update", "Updates fields of an existing document.")
+    DELETE = ("delete", "Removes a document.")
+    HELP = ("help", "Shows available actions and their uses.")
 
     @classmethod
     def choices(cls) -> List[str]:
@@ -41,7 +41,7 @@ class UserConfigAction(str, Enum):
     @classmethod
     def formatted_help(cls) -> str:
         lines = [
-            "| **Ação** | **Descrição** |",
+            "| **Action** | **Description** |",
             "| --- | --- |",
         ]
         for member in cls:
@@ -49,7 +49,7 @@ class UserConfigAction(str, Enum):
         return "\n".join(lines)
 
 
-ACTION_FIELD_DESCRIPTION = "Ação a executar. Escolha um dos valores: " + ", ".join(
+ACTION_FIELD_DESCRIPTION = "Action to execute. Choose one of the values: " + ", ".join(
     f"`{member.value}` ({member.description.rstrip('.')})."
     for member in UserConfigAction
 )
@@ -57,30 +57,30 @@ ACTION_FIELD_DESCRIPTION = "Ação a executar. Escolha um dos valores: " + ", ".
 
 class UserConfigRequest(ToolRequest):
     action: UserConfigAction = Field(description=ACTION_FIELD_DESCRIPTION)
-    id: Optional[UUIDStr] = Field(default=None, description="ID do documento (UUID).")
-    name: Optional[TitleStr] = Field(default=None, description="Nome do documento.")
+    id: Optional[UUIDStr] = Field(default=None, description="Document ID (UUID).")
+    name: Optional[TitleStr] = Field(default=None, description="Document name.")
     content: Optional[MarkdownStr] = Field(
-        default=None, description="Conteúdo em Markdown/JSON."
+        default=None, description="Content in Markdown/JSON."
     )
     mode_id: Optional[UUIDStr] = Field(
-        default=None, description="ID do modo associado (UUID)."
+        default=None, description="Associated mode ID (UUID)."
     )
     is_default: Optional[bool] = Field(
-        default=None, description="Marca o documento como padrão."
+        default=None, description="Marks the document as default."
     )
     metadata: Optional[MarkdownStr] = Field(
-        default=None, description="Metadata estruturada do documento (Markdown)."
+        default=None, description="Structured document metadata (Markdown)."
     )
-    limit: int = Field(default=20, ge=1, le=100, description="Limite para listagem.")
-    offset: int = Field(default=0, ge=0, description="Offset para listagem.")
+    limit: int = Field(default=20, ge=1, le=100, description="Listing limit.")
+    offset: int = Field(default=0, ge=0, description="Listing offset.")
     return_content: Optional[bool] = Field(
-        default=None, description="Retorna conteúdo completo."
+        default=None, description="Return full content."
     )
 
 
 class UserConfigTool(Tool):
     name = "user_config"
-    description = "Gerencia documentos de configuração do usuário (Core Documents)."
+    description = "Manages user configuration documents (Core Documents)."
     request_model = UserConfigRequest
 
     def __init__(self, context: AppContext):
@@ -93,7 +93,7 @@ class UserConfigTool(Tool):
             return await self._handle_help()
         if action is UserConfigAction.CREATE:
             if not payload.name or not payload.content:
-                return text("❌ Informe name e content para criar o documento.")
+                return text("❌ Provide name and content to create the document.")
             doc = await self._service.create(
                 _strip_none(
                     {
@@ -105,7 +105,7 @@ class UserConfigTool(Tool):
                     }
                 )
             )
-            return text(_format_doc(doc, header="✅ Documento criado"))
+            return text(_format_doc(doc, header="✅ Document created"))
 
         if action is UserConfigAction.LIST:
             docs = await self._service.list(
@@ -114,22 +114,22 @@ class UserConfigTool(Tool):
                 returnContent=payload.return_content,
             )
             if not docs:
-                return text("📂 Nenhum documento encontrado.")
+                return text("📂 No documents found.")
             body = "\n\n".join(_format_doc(doc) for doc in docs)
-            return text(f"📂 **Documentos ({len(docs)}):**\n\n{body}")
+            return text(f"📂 **Documents ({len(docs)}):**\n\n{body}")
 
         if action is UserConfigAction.GET:
             if not payload.id:
-                return text("❌ Informe o ID do documento.")
+                return text("❌ Provide the document ID.")
             doc = await self._service.get(
                 payload.id,
                 returnContent=payload.return_content,
             )
-            return text(_format_doc(doc, header="📂 Detalhes do documento"))
+            return text(_format_doc(doc, header="📂 Document details"))
 
         if action is UserConfigAction.UPDATE:
             if not payload.id:
-                return text("❌ Informe o ID do documento para atualizar.")
+                return text("❌ Provide the document ID to update.")
             data = _strip_none(
                 {
                     "name": payload.name,
@@ -140,22 +140,22 @@ class UserConfigTool(Tool):
                 }
             )
             doc = await self._service.update(payload.id, data)
-            return text(_format_doc(doc, header="✅ Documento atualizado"))
+            return text(_format_doc(doc, header="✅ Document updated"))
 
         if action is UserConfigAction.DELETE:
             if not payload.id:
-                return text("❌ Informe o ID do documento.")
+                return text("❌ Provide the document ID.")
             await self._service.delete(payload.id)
-            return text(f"🗑️ Documento {payload.id} removido.")
+            return text(f"🗑️ Document {payload.id} removed.")
 
         return text(
-            "❌ Ação de user_config não suportada.\n\nEscolha um dos valores:\n"
+            "❌ Unsupported user_config action.\n\nChoose one of the values:\n"
             + "\n".join(f"- `{value}`" for value in UserConfigAction.choices())
         )
 
     async def _handle_help(self):
         return text(
-            "📚 **Ações disponíveis para user_config**\n\n"
+            "📚 **Available actions for user_config**\n\n"
             + UserConfigAction.formatted_help()
         )
 
@@ -167,13 +167,13 @@ def _format_doc(doc: Dict[str, Any], header: Optional[str] = None) -> str:
         lines.append("")
     lines.extend(
         [
-            f"📂 **{doc.get('name', 'Sem nome')}**",
+            f"📂 **{doc.get('name', 'Unnamed')}**",
             f"ID: {doc.get('id', 'N/A')}",
             f"Default: {doc.get('is_default', False)}",
         ]
     )
     if doc.get("mode_id"):
-        lines.append(f"Modo associado: {doc['mode_id']}")
+        lines.append(f"Associated mode: {doc['mode_id']}")
     if doc.get("content") and len(doc["content"]) <= 400:
         lines.append("")
         lines.append(doc["content"])

fenix_mcp/domain/knowledge.py

@@ -75,38 +75,30 @@ class KnowledgeService:
     async def work_update(
         self, work_id: str, payload: Dict[str, Any]
     ) -> Dict[str, Any]:
-        return await self._call(
+        return await self._call_dict(
             self.api.update_work_item, work_id, _strip_none(payload)
         )
 
     async def work_delete(self, work_id: str) -> None:
         await self._call(self.api.delete_work_item, work_id)
 
-    async def work_backlog(self, *, team_id: str) -> List[Dict[str, Any]]:
-        return await self._call_list(self.api.list_work_items_backlog, team_id=team_id)
+    async def work_backlog(self) -> List[Dict[str, Any]]:
+        return await self._call_list(self.api.list_work_items_backlog)
 
-    async def work_search(
-        self, *, query: str, team_id: str, limit: int
-    ) -> List[Dict[str, Any]]:
+    async def work_search(self, *, query: str, limit: int) -> List[Dict[str, Any]]:
         return await self._call_list(
             self.api.search_work_items,
             query=query,
-            team_id=team_id,
             limit=limit,
         )
 
-    async def work_analytics(self, *, team_id: str) -> Dict[str, Any]:
-        return (
-            await self._call(self.api.get_work_items_analytics, team_id=team_id) or {}
-        )
+    async def work_analytics(self) -> Dict[str, Any]:
+        return await self._call(self.api.get_work_items_analytics) or {}
 
-    async def work_velocity(
-        self, *, team_id: str, sprints_count: int
-    ) -> Dict[str, Any]:
+    async def work_velocity(self, *, sprints_count: int) -> Dict[str, Any]:
         return (
             await self._call(
                 self.api.get_work_items_velocity,
-                team_id=team_id,
                 sprints_count=sprints_count,
             )
             or {}
@@ -178,21 +170,18 @@ class KnowledgeService:
         result = await self._call(self.api.list_work_boards, **_strip_none(filters))
         return _ensure_list(result)
 
-    async def board_list_by_team(self, team_id: str) -> List[Dict[str, Any]]:
-        result = await self._call(self.api.list_work_boards_by_team, team_id=team_id)
+    async def board_list_by_team(self) -> List[Dict[str, Any]]:
+        result = await self._call(self.api.list_work_boards_by_team)
         return _ensure_list(result)
 
     async def board_favorites(self) -> List[Dict[str, Any]]:
         result = await self._call(self.api.list_favorite_work_boards)
         return _ensure_list(result)
 
-    async def board_search(
-        self, *, query: str, team_id: str, limit: int
-    ) -> List[Dict[str, Any]]:
+    async def board_search(self, *, query: str, limit: int) -> List[Dict[str, Any]]:
         result = await self._call(
             self.api.search_work_boards,
             query=query,
-            team_id=team_id,
             limit=limit,
         )
         return _ensure_list(result)
@@ -280,27 +269,21 @@ class KnowledgeService:
     async def sprint_delete(self, sprint_id: str) -> None:
         await self._call(self.api.delete_sprint, sprint_id)
 
-    async def sprint_list_by_team(self, team_id: str) -> List[Dict[str, Any]]:
-        return await self._call_list(self.api.list_sprints_by_team, team_id=team_id)
+    async def sprint_list_by_team(self) -> List[Dict[str, Any]]:
+        return await self._call_list(self.api.list_sprints_by_team)
 
-    async def sprint_recent(self, *, team_id: str, limit: int) -> List[Dict[str, Any]]:
-        return (
-            await self._call(self.api.list_recent_sprints, team_id=team_id, limit=limit)
-            or []
-        )
+    async def sprint_recent(self, *, limit: int) -> List[Dict[str, Any]]:
+        return await self._call(self.api.list_recent_sprints, limit=limit) or []
 
-    async def sprint_search(
-        self, *, query: str, team_id: str, limit: int
-    ) -> List[Dict[str, Any]]:
+    async def sprint_search(self, *, query: str, limit: int) -> List[Dict[str, Any]]:
         return await self._call_list(
             self.api.search_sprints,
             query=query,
-            team_id=team_id,
             limit=limit,
         )
 
-    async def sprint_active(self, team_id: str) -> Dict[str, Any]:
-        return await self._call(self.api.get_active_sprint, team_id=team_id) or {}
+    async def sprint_active(self) -> Dict[str, Any]:
+        return await self._call(self.api.get_active_sprint) or {}
 
     async def sprint_velocity(self) -> Dict[str, Any]:
         return await self._call(self.api.get_sprints_velocity) or {}
@@ -348,7 +331,11 @@ class KnowledgeService:
     # Modes and rules
     # ------------------------------------------------------------------
     async def mode_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.create_mode, _strip_none(payload))
+        result = await self._call(self.api.create_mode, _strip_none(payload))
+        # API returns { message, mode } - extract mode
+        if isinstance(result, dict) and "mode" in result:
+            return result["mode"]
+        return result or {}
 
     async def mode_list(
         self,
@@ -384,7 +371,11 @@ class KnowledgeService:
     async def mode_update(
         self, mode_id: str, payload: Dict[str, Any]
     ) -> Dict[str, Any]:
-        return await self._call(self.api.update_mode, mode_id, _strip_none(payload))
+        result = await self._call(self.api.update_mode, mode_id, _strip_none(payload))
+        # API returns { message, mode } - extract mode
+        if isinstance(result, dict) and "mode" in result:
+            return result["mode"]
+        return result or {}
 
     async def mode_delete(self, mode_id: str) -> None:
         await self._call(self.api.delete_mode, mode_id)
@@ -402,7 +393,11 @@ class KnowledgeService:
         return await self._call(self.api.list_modes_by_rule, rule_id) or []
 
     async def rule_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.create_rule, _strip_none(payload))
+        result = await self._call(self.api.create_rule, _strip_none(payload))
+        # API returns { message, rule } - extract rule
+        if isinstance(result, dict) and "rule" in result:
+            return result["rule"]
+        return result or {}
 
     async def rule_list(
         self,
@@ -440,7 +435,11 @@ class KnowledgeService:
     async def rule_update(
         self, rule_id: str, payload: Dict[str, Any]
     ) -> Dict[str, Any]:
-        return await self._call(self.api.update_rule, rule_id, _strip_none(payload))
+        result = await self._call(self.api.update_rule, rule_id, _strip_none(payload))
+        # API returns { message, rule } - extract rule
+        if isinstance(result, dict) and "rule" in result:
+            return result["rule"]
+        return result or {}
 
     async def rule_delete(self, rule_id: str) -> None:
         await self._call(self.api.delete_rule, rule_id)
@@ -473,31 +472,27 @@ class KnowledgeService:
     async def doc_delete(self, doc_id: str) -> None:
         await self._call(self.api.delete_documentation_item, doc_id)
 
-    async def doc_search(
-        self, *, query: str, team_id: str, limit: int
-    ) -> List[Dict[str, Any]]:
+    async def doc_search(self, *, query: str, limit: int) -> List[Dict[str, Any]]:
         result = await self._call(
             self.api.search_documentation_items,
             query=query,
-            team_id=team_id,
             limit=limit,
         )
         return _ensure_list(result)
 
-    async def doc_roots(self, *, team_id: str) -> List[Dict[str, Any]]:
-        result = await self._call(self.api.list_documentation_roots, team_id=team_id)
+    async def doc_roots(self) -> List[Dict[str, Any]]:
+        result = await self._call(self.api.list_documentation_roots)
         return _ensure_list(result)
 
-    async def doc_recent(self, *, team_id: str, limit: int) -> List[Dict[str, Any]]:
+    async def doc_recent(self, *, limit: int) -> List[Dict[str, Any]]:
         result = await self._call(
             self.api.list_documentation_recent,
-            team_id=team_id,
             limit=limit,
         )
         return _ensure_list(result)
 
-    async def doc_analytics(self, *, team_id: str) -> Dict[str, Any]:
-        result = await self._call(self.api.get_documentation_analytics, team_id=team_id)
+    async def doc_analytics(self) -> Dict[str, Any]:
+        result = await self._call(self.api.get_documentation_analytics)
         return _ensure_dict(result)
 
     async def doc_children(self, doc_id: str) -> List[Dict[str, Any]]:

fenix_mcp/domain/user_config.py

@@ -19,7 +19,11 @@ class UserConfigService:
 
     async def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
         payload = _strip_none(data)
-        return await asyncio.to_thread(self._api.create_user_core_document, payload)
+        result = await asyncio.to_thread(self._api.create_user_core_document, payload)
+        # API returns { message, document } - extract document
+        if isinstance(result, dict) and "document" in result:
+            return result["document"]
+        return result or {}
 
     async def list(
         self, *, returnContent: Optional[bool] = None, **_: Any
@@ -43,9 +47,13 @@ class UserConfigService:
 
     async def update(self, doc_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
         payload = _strip_none(data)
-        return await asyncio.to_thread(
+        result = await asyncio.to_thread(
             self._api.update_user_core_document, doc_id, payload
         )
+        # API returns { message, document } - extract document
+        if isinstance(result, dict) and "document" in result:
+            return result["document"]
+        return result or {}
 
     async def delete(self, doc_id: str) -> None:
         await asyncio.to_thread(self._api.delete_user_core_document, doc_id)