fenix-mcp 0.5.5__tar.gz → 0.5.7__tar.gz

{fenix_mcp-0.5.5 → fenix_mcp-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fenix-mcp
-Version: 0.5.5
+Version: 0.5.7
 Summary: Fênix Cloud MCP server implemented in Python
 Author: Fenix Inc
 Requires-Python: >=3.10

{fenix_mcp-0.5.5 → fenix_mcp-0.5.7}/fenix_mcp/__init__.py

@@ -8,4 +8,4 @@ Fênix Cloud MCP Server (Python edition).
 __all__ = ["__version__"]
 
 
-__version__ = "0.5.5"
+__version__ = "0.5.7"

{fenix_mcp-0.5.5 → fenix_mcp-0.5.7}/fenix_mcp/application/tools/intelligence.py

@@ -155,7 +155,21 @@ class IntelligenceTool(Tool):
     async def _handle_smart_create(self, payload: IntelligenceRequest):
         if not payload.title or not payload.content:
             return text("❌ Informe título e conteúdo para criar uma memória.")
-        normalized_tags = _ensure_tag_sequence(payload.tags)
+
+        if not payload.metadata or not payload.metadata.strip():
+            return text("❌ Informe metadata para criar uma memória.")
+
+        if not payload.source or not payload.source.strip():
+            return text("❌ Informe source para criar uma memória.")
+
+        try:
+            normalized_tags = _ensure_tag_sequence(payload.tags)
+        except ValueError as exc:
+            return text(f"❌ {exc}")
+
+        if not normalized_tags or len(normalized_tags) == 0:
+            return text("❌ Informe tags para criar uma memória.")
+
         memory = await self._service.smart_create_memory(
             title=payload.title,
             content=payload.content,
@@ -260,11 +274,15 @@ class IntelligenceTool(Tool):
         existing = await self._service.get_memory(
             payload.id, include_content=False, include_metadata=True
         )
-        normalized_tags = _ensure_tag_sequence(payload.tags)
+        try:
+            normalized_tags = _ensure_tag_sequence(payload.tags)
+        except ValueError as exc:
+            return text(f"❌ {exc}")
         metadata = build_metadata(
             payload.metadata,
             importance=payload.importance,
             tags=normalized_tags,
+            source=payload.source,
             existing=existing.get("metadata") if isinstance(existing, dict) else None,
         )
         update_fields: Dict[str, Any] = {
@@ -324,6 +342,8 @@ def _ensure_tag_sequence(raw: Optional[Any]) -> Optional[List[str]]:
         result = [str(item).strip() for item in raw if str(item).strip()]
         return result or None
     if isinstance(raw, str):
-        items = [part.strip() for part in raw.split(",") if part.strip()]
-        return items or None
+        raise ValueError(
+            "O campo `tags` deve ser enviado como array JSON, por exemplo: "
+            '["tag1", "tag2"].'
+        )
     return [str(raw).strip()]

{fenix_mcp-0.5.5 → fenix_mcp-0.5.7}/fenix_mcp/domain/intelligence.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Optional, Union
+from typing import Any, Dict, Iterable, List, Optional
 
 from fenix_mcp.infrastructure.fenix_api.client import FenixApiClient
 
@@ -20,18 +20,34 @@ class IntelligenceService:
         *,
         title: str,
         content: str,
-        metadata: Optional[str],
+        metadata: str,
         context: Optional[str],
-        source: Optional[str],
+        source: str,
         importance: str,
-        tags: Optional[Union[Iterable[str], str]] = None,
+        tags: List[str],
     ) -> Dict[str, Any]:
+        # Validate required parameters
+        if not metadata or not metadata.strip():
+            raise ValueError("metadata is required and cannot be empty")
+
+        if not source or not source.strip():
+            raise ValueError("source is required and cannot be empty")
+
+        if not tags or not isinstance(tags, list) or len(tags) == 0:
+            raise ValueError("tags is required and must be a non-empty List[str]")
+
+        # Validate all tags are strings
+        for i, tag in enumerate(tags):
+            if not isinstance(tag, str) or not tag.strip():
+                raise ValueError(
+                    f"All tags must be non-empty strings, got {type(tag)} at index {i}"
+                )
+
         importance_value = importance or "medium"
-        normalized_tags = normalize_tags(tags)
         metadata_str = build_metadata(
             metadata,
             importance=importance_value,
-            tags=normalized_tags,
+            tags=tags,
             context=context,
             source=source,
         )
@@ -40,7 +56,7 @@ class IntelligenceService:
             "content": content,
             "metadata": metadata_str,
             "priority_score": _importance_to_priority(importance_value),
-            "tags": normalized_tags,
+            "tags": tags,
         }
         return await self._call(self.api.smart_create_memory, _strip_none(payload))
 
@@ -197,12 +213,12 @@ def _strip_none(data: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def build_metadata(
-    explicit: Optional[str],
+    explicit: str,
     *,
     importance: Optional[str],
-    tags: Optional[Union[Iterable[str], str]],
+    tags: List[str],
     context: Optional[str] = None,
-    source: Optional[str] = None,
+    source: str,
     existing: Optional[str] = None,
 ) -> str:
     if explicit and explicit.strip():
@@ -259,31 +275,37 @@ def _slugify(value: Optional[str]) -> str:
     return "-".join(part for part in sanitized.split() if part).lower()
 
 
-def _format_tags(tags: Optional[Union[Iterable[str], str]]) -> str:
-    if tags is None or tags == "":
-        return ""
-    if isinstance(tags, str):
-        iterable: Iterable[str] = [part.strip() for part in tags.split(",")]
-    else:
-        iterable = tags
-    normalized = {
-        _slugify(tag) for tag in iterable if isinstance(tag, str) and _slugify(tag)
-    }
-    if not normalized:
-        return ""
-    return ",".join(sorted(normalized))
-
-
-def normalize_tags(tags: Optional[Union[Iterable[str], str]]) -> Optional[List[str]]:
-    if tags is None or tags == "":
-        return None
-    if isinstance(tags, str):
-        parts = [part.strip() for part in tags.split(",") if part.strip()]
-    else:
-        parts = [str(part).strip() for part in tags if str(part).strip()]
-    if not parts:
-        return None
-    slugged = [_slugify(part) for part in parts if _slugify(part)]
-    if not slugged:
-        return None
-    return sorted(set(slugged))
+def _format_tags(tags: List[str]) -> str:
+    """
+    Format tags list into a comma-separated string for metadata.
+
+    Args:
+        tags: List of string tags (required)
+
+    Returns:
+        Comma-separated string of tags
+
+    Raises:
+        TypeError: If tags is not a List[str]
+        ValueError: If tags is empty
+    """
+    if not isinstance(tags, list):
+        raise TypeError(f"tags must be List[str], got {type(tags)}")
+
+    if not tags:
+        raise ValueError("tags cannot be empty")
+
+    # Clean and validate tags
+    cleaned_tags = []
+    for tag in tags:
+        if isinstance(tag, str) and tag.strip():
+            cleaned_tags.append(tag.strip())
+        else:
+            raise ValueError(
+                f"All tags must be non-empty strings, got {type(tag)}: {tag}"
+            )
+
+    if not cleaned_tags:
+        raise ValueError("No valid tags found after cleaning")
+
+    return ",".join(sorted(set(cleaned_tags)))

{fenix_mcp-0.5.5 → fenix_mcp-0.5.7}/fenix_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fenix-mcp
-Version: 0.5.5
+Version: 0.5.7
 Summary: Fênix Cloud MCP server implemented in Python
 Author: Fenix Inc
 Requires-Python: >=3.10