nornweave 0.1.3__tar.gz → 0.1.4__tar.gz

{nornweave-0.1.3 → nornweave-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nornweave
-Version: 0.1.3
+Version: 0.1.4
 Summary: Open-source, self-hosted Inbox-as-a-Service API for AI Agents
 Project-URL: Homepage, https://github.com/DataCovey/nornweave
 Project-URL: Documentation, https://nornweave.datacovey.com/docs/
@@ -38,8 +38,12 @@ Requires-Dist: sqlalchemy[asyncio]>=2.0.36
 Requires-Dist: svix>=1.24.0
 Requires-Dist: uvicorn[standard]>=0.32.0
 Provides-Extra: all
+Requires-Dist: anthropic>=0.42.0; extra == 'all'
 Requires-Dist: asyncpg>=0.30.0; extra == 'all'
+Requires-Dist: boto3>=1.35.0; extra == 'all'
 Requires-Dist: fastmcp>=2.0.0; extra == 'all'
+Requires-Dist: google-cloud-storage>=2.18.0; extra == 'all'
+Requires-Dist: google-genai>=1.0.0; extra == 'all'
 Requires-Dist: mcp>=1.0.0; extra == 'all'
 Requires-Dist: openai>=1.57.0; extra == 'all'
 Requires-Dist: pgvector>=0.3.6; extra == 'all'
@@ -47,6 +51,8 @@ Requires-Dist: psycopg2-binary>=2.9.0; extra == 'all'
 Requires-Dist: pypdf>=5.1.0; extra == 'all'
 Requires-Dist: python-magic>=0.4.27; extra == 'all'
 Requires-Dist: redis>=5.2.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.42.0; extra == 'anthropic'
 Provides-Extra: attachments
 Requires-Dist: pypdf>=5.1.0; extra == 'attachments'
 Requires-Dist: python-magic>=0.4.27; extra == 'attachments'
@@ -59,14 +65,26 @@ Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
 Requires-Dist: pytest-cov>=6.0.0; extra == 'dev'
 Requires-Dist: pytest>=8.3.0; extra == 'dev'
 Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Provides-Extra: gcs
+Requires-Dist: google-cloud-storage>=2.18.0; extra == 'gcs'
+Provides-Extra: gemini
+Requires-Dist: google-genai>=1.0.0; extra == 'gemini'
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.42.0; extra == 'llm'
+Requires-Dist: google-genai>=1.0.0; extra == 'llm'
+Requires-Dist: openai>=1.57.0; extra == 'llm'
 Provides-Extra: mcp
 Requires-Dist: fastmcp>=2.0.0; extra == 'mcp'
 Requires-Dist: mcp>=1.0.0; extra == 'mcp'
+Provides-Extra: openai
+Requires-Dist: openai>=1.57.0; extra == 'openai'
 Provides-Extra: postgres
 Requires-Dist: asyncpg>=0.30.0; extra == 'postgres'
 Requires-Dist: psycopg2-binary>=2.9.0; extra == 'postgres'
 Provides-Extra: ratelimit
 Requires-Dist: redis>=5.2.0; extra == 'ratelimit'
+Provides-Extra: s3
+Requires-Dist: boto3>=1.35.0; extra == 's3'
 Provides-Extra: search
 Requires-Dist: openai>=1.57.0; extra == 'search'
 Requires-Dist: pgvector>=0.3.6; extra == 'search'

{nornweave-0.1.3 → nornweave-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nornweave"
-version = "0.1.3"
+version = "0.1.4"
 description = "Open-source, self-hosted Inbox-as-a-Service API for AI Agents"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -62,9 +62,30 @@ search = [
 ratelimit = [
     "redis>=5.2.0",
 ]
+# AWS S3 attachment storage
+s3 = [
+    "boto3>=1.35.0",
+]
+# Google Cloud Storage attachment storage
+gcs = [
+    "google-cloud-storage>=2.18.0",
+]
+# LLM providers for thread summarization
+openai = [
+    "openai>=1.57.0",
+]
+anthropic = [
+    "anthropic>=0.42.0",
+]
+gemini = [
+    "google-genai>=1.0.0",
+]
+llm = [
+    "nornweave[openai,anthropic,gemini]",
+]
 # All optional dependencies
 all = [
-    "nornweave[postgres,mcp,attachments,search,ratelimit]",
+    "nornweave[postgres,mcp,attachments,search,ratelimit,s3,gcs,llm]",
 ]
 # Development dependencies
 dev = [
@@ -197,7 +218,13 @@ module = [
     "talon",
     "talon.*",
     "boto3",
+    "google",
+    "google.*",
     "google.cloud.*",
+    "google.genai",
+    "google.genai.*",
+    "anthropic",
+    "anthropic.*",
     "pdfplumber",
     "svix",
     "svix.*",

{nornweave-0.1.3 → nornweave-0.1.4}/src/nornweave/adapters/resend.py

@@ -253,38 +253,88 @@ class ResendAdapter(EmailProvider):
             result: dict[str, Any] = response.json()
             return result
 
-    async def fetch_attachment_content(self, email_id: str, attachment_id: str) -> bytes:
+    async def fetch_attachment_content(
+        self, email_id: str, attachment_id: str, *, inbound: bool = True
+    ) -> bytes:
         """Fetch attachment content from Resend API.
 
+        The Resend API returns attachment metadata with a download_url.
+        This method fetches the metadata, then downloads the actual content.
+
+        See:
+        - Inbound: https://resend.com/docs/api-reference/emails/retrieve-received-email-attachment
+        - Outbound: https://resend.com/docs/api-reference/emails/retrieve-email-attachment
+
         Args:
             email_id: Resend email ID
             attachment_id: Attachment ID from webhook/email data
+            inbound: If True, use receiving endpoint; if False, use sending endpoint
 
         Returns:
             Attachment binary content
         """
-        url = f"{self._api_url}/emails/receiving/{email_id}/attachments/{attachment_id}"
+        # Step 1: Get attachment metadata (contains download_url)
+        # Use different endpoints for inbound vs outbound emails
+        if inbound:
+            metadata_url = (
+                f"{self._api_url}/emails/receiving/{email_id}/attachments/{attachment_id}"
+            )
+        else:
+            metadata_url = f"{self._api_url}/emails/{email_id}/attachments/{attachment_id}"
 
-        logger.debug("Fetching attachment %s from email %s", attachment_id, email_id)
+        logger.debug("Fetching attachment metadata %s from email %s", attachment_id, email_id)
 
         async with httpx.AsyncClient() as client:
             response = await client.get(
-                url,
+                metadata_url,
                 headers={
                     "Authorization": f"Bearer {self._api_key}",
                 },
-                timeout=60.0,
+                timeout=30.0,
             )
 
             if response.status_code != 200:
                 logger.error(
-                    "Resend API error fetching attachment: %s - %s",
+                    "Resend API error fetching attachment metadata: %s - %s",
                     response.status_code,
                     response.text,
                 )
                 response.raise_for_status()
 
-            return response.content
+            metadata = response.json()
+            download_url = metadata.get("download_url")
+
+            if not download_url:
+                raise ValueError(f"No download_url in attachment metadata: {metadata}")
+
+            logger.debug(
+                "Got attachment metadata: filename=%s, size=%s, downloading from %s",
+                metadata.get("filename"),
+                metadata.get("size"),
+                download_url[:50] + "..." if len(download_url) > 50 else download_url,
+            )
+
+            # Step 2: Download actual content from the CDN URL
+            content_response = await client.get(
+                download_url,
+                timeout=60.0,
+                follow_redirects=True,
+            )
+
+            if content_response.status_code != 200:
+                logger.error(
+                    "Error downloading attachment content: %s - %s",
+                    content_response.status_code,
+                    content_response.text[:200] if content_response.text else "No content",
+                )
+                content_response.raise_for_status()
+
+            logger.debug(
+                "Downloaded attachment content: %d bytes",
+                len(content_response.content),
+            )
+
+            return content_response.content
 
     def parse_inbound_webhook(self, payload: dict[str, Any]) -> InboundMessage:
         """Parse Resend inbound webhook payload into standardized InboundMessage.

{nornweave-0.1.3 → nornweave-0.1.4}/src/nornweave/core/config.py

@@ -3,7 +3,7 @@
 from functools import lru_cache
 from typing import Literal
 
-from pydantic import Field
+from pydantic import Field, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -146,6 +146,44 @@ class Settings(BaseSettings):
         description="Maximum number of attachments per message",
     )
 
+    # -------------------------------------------------------------------------
+    # LLM Thread Summarization Configuration
+    # -------------------------------------------------------------------------
+    llm_provider: Literal["openai", "anthropic", "gemini"] | None = Field(
+        default=None,
+        alias="LLM_PROVIDER",
+        description="LLM provider for thread summarization. None = feature disabled.",
+    )
+    llm_api_key: str = Field(
+        default="",
+        alias="LLM_API_KEY",
+        description="API key for the selected LLM provider",
+    )
+    llm_model: str = Field(
+        default="",
+        alias="LLM_MODEL",
+        description="Model override (auto-selected per provider if empty)",
+    )
+    llm_summary_prompt: str = Field(
+        default=(
+            "You are an email thread summarizer. Given a chronological email conversation, "
+            "produce a concise summary that captures:\n"
+            "- Key topics discussed\n"
+            "- Decisions made or actions agreed upon\n"
+            "- Open questions or pending items\n"
+            "- Current status of the conversation\n\n"
+            "Keep the summary under 300 words. Use bullet points for clarity.\n"
+            "Do not include greetings, sign-offs, or meta-commentary."
+        ),
+        alias="LLM_SUMMARY_PROMPT",
+        description="System prompt for thread summarization",
+    )
+    llm_daily_token_limit: int = Field(
+        default=1_000_000,
+        alias="LLM_DAILY_TOKEN_LIMIT",
+        description="Max tokens per day for summarization (0 = unlimited)",
+    )
+
     # -------------------------------------------------------------------------
     # Content Extraction Configuration (Talon)
     # -------------------------------------------------------------------------
@@ -165,6 +203,17 @@ class Settings(BaseSettings):
         description="Return original content if extraction fails",
     )
 
+    @model_validator(mode="after")
+    def validate_llm_config(self) -> Settings:
+        """Validate LLM configuration: API key is required when provider is set."""
+        if self.llm_provider is not None and not self.llm_api_key:
+            msg = (
+                f"LLM_API_KEY is required when LLM_PROVIDER is set to '{self.llm_provider}'. "
+                "Set LLM_API_KEY in your environment or .env file."
+            )
+            raise ValueError(msg)
+        return self
+
 
 @lru_cache
 def get_settings() -> Settings:

{nornweave-0.1.3 → nornweave-0.1.4}/src/nornweave/core/interfaces.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import date, datetime
 from typing import TYPE_CHECKING, Any
 
 from nornweave.models.attachment import AttachmentDisposition, SendAttachment
@@ -252,6 +252,31 @@ class StorageInterface(ABC):
         """Search messages by content (ILIKE/LIKE on content_clean and content_raw)."""
         ...
 
+    @abstractmethod
+    async def search_messages_advanced(
+        self,
+        *,
+        inbox_id: str | None = None,
+        thread_id: str | None = None,
+        query: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> tuple[list[Message], int]:
+        """
+        Search messages with flexible filters.
+
+        Args:
+            inbox_id: Filter by inbox (optional)
+            thread_id: Filter by thread (optional)
+            query: Text search across subject, text, from_address, attachment filenames
+            limit: Maximum results to return
+            offset: Pagination offset
+
+        Returns:
+            Tuple of (messages, total_count)
+        """
+        ...
+
     # -------------------------------------------------------------------------
     # Event methods (Phase 3 webhooks)
     # -------------------------------------------------------------------------
@@ -291,6 +316,8 @@ class StorageInterface(ABC):
         content_id: str | None = None,
         storage_path: str | None = None,
         storage_backend: str | None = None,
+        content_hash: str | None = None,
+        content: bytes | None = None,
     ) -> str:
         """Create attachment record. Returns attachment ID."""
         ...
@@ -305,6 +332,28 @@ class StorageInterface(ABC):
         """List attachments for a message."""
         ...
 
+    @abstractmethod
+    async def list_attachments_for_thread(
+        self,
+        thread_id: str,
+        *,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        """List attachments for all messages in a thread."""
+        ...
+
+    @abstractmethod
+    async def list_attachments_for_inbox(
+        self,
+        inbox_id: str,
+        *,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        """List attachments for all messages in an inbox."""
+        ...
+
     @abstractmethod
     async def delete_attachment(self, attachment_id: str) -> bool:
         """Delete attachment. Returns True if deleted."""
@@ -331,6 +380,19 @@ class StorageInterface(ABC):
         """Get thread by normalized subject within time window (for subject-based threading)."""
         ...
 
+    # -------------------------------------------------------------------------
+    # LLM Token Usage methods
+    # -------------------------------------------------------------------------
+    @abstractmethod
+    async def get_token_usage(self, usage_date: date) -> int:
+        """Get total tokens used for a given date. Returns 0 if no record exists."""
+        ...
+
+    @abstractmethod
+    async def record_token_usage(self, usage_date: date, tokens: int) -> None:
+        """Record token usage for a given date. Creates or increments the daily counter."""
+        ...
+
 
 class EmailProvider(ABC):
     """Abstract email provider (BYOP). Implementations: Mailgun, SES, SendGrid, Resend."""

{nornweave-0.1.3 → nornweave-0.1.4}/src/nornweave/huginn/client.py

@@ -173,25 +173,36 @@ class NornWeaveClient:
 
     async def list_messages(
         self,
-        inbox_id: str,
+        inbox_id: str | None = None,
+        thread_id: str | None = None,
+        q: str | None = None,
         limit: int = 50,
         offset: int = 0,
     ) -> dict[str, Any]:
-        """List messages for an inbox.
+        """List and search messages with flexible filters.
+
+        At least one of inbox_id or thread_id must be provided.
 
         Args:
-            inbox_id: The inbox ID.
+            inbox_id: Filter by inbox ID (optional).
+            thread_id: Filter by thread ID (optional).
+            q: Text search query (optional).
             limit: Maximum number of messages to return.
             offset: Number of messages to skip.
 
         Returns:
-            List response with messages.
+            List response with messages, count, and total.
         """
         client = await self._get_client()
-        response = await client.get(
-            "/v1/messages",
-            params={"inbox_id": inbox_id, "limit": limit, "offset": offset},
-        )
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if inbox_id:
+            params["inbox_id"] = inbox_id
+        if thread_id:
+            params["thread_id"] = thread_id
+        if q:
+            params["q"] = q
+
+        response = await client.get("/v1/messages", params=params)
         response.raise_for_status()
         return cast("dict[str, Any]", response.json())
 
@@ -294,3 +305,121 @@ class NornWeaveClient:
         if not messages:
             return None
         return cast("dict[str, Any]", messages[-1])
+
+    # -------------------------------------------------------------------------
+    # Attachment Operations
+    # -------------------------------------------------------------------------
+
+    async def list_attachments(
+        self,
+        message_id: str | None = None,
+        thread_id: str | None = None,
+        inbox_id: str | None = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List attachments filtered by message, thread, or inbox.
+
+        Args:
+            message_id: Filter by message ID.
+            thread_id: Filter by thread ID.
+            inbox_id: Filter by inbox ID.
+            limit: Maximum number of attachments to return.
+            offset: Number of attachments to skip.
+
+        Returns:
+            List response with attachment metadata.
+        """
+        client = await self._get_client()
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if message_id:
+            params["message_id"] = message_id
+        elif thread_id:
+            params["thread_id"] = thread_id
+        elif inbox_id:
+            params["inbox_id"] = inbox_id
+
+        response = await client.get("/v1/attachments", params=params)
+        response.raise_for_status()
+        return cast("dict[str, Any]", response.json())
+
+    async def get_attachment(self, attachment_id: str) -> dict[str, Any]:
+        """Get attachment metadata.
+
+        Args:
+            attachment_id: The attachment ID.
+
+        Returns:
+            Attachment metadata with download_url.
+        """
+        client = await self._get_client()
+        response = await client.get(f"/v1/attachments/{attachment_id}")
+        response.raise_for_status()
+        return cast("dict[str, Any]", response.json())
+
+    async def get_attachment_content(
+        self,
+        attachment_id: str,
+        response_format: str = "base64",
+    ) -> dict[str, Any]:
+        """Get attachment content.
+
+        Args:
+            attachment_id: The attachment ID.
+            response_format: Response format - "binary" or "base64" (default: base64).
+
+        Returns:
+            For base64: {"content": "...", "content_type": "...", "filename": "..."}
+            For binary: raw bytes (handled by httpx)
+        """
+        client = await self._get_client()
+        response = await client.get(
+            f"/v1/attachments/{attachment_id}/content",
+            params={"format": response_format},
+        )
+        response.raise_for_status()
+        return cast("dict[str, Any]", response.json())
+
+    async def send_message_with_attachments(
+        self,
+        inbox_id: str,
+        to: list[str],
+        subject: str,
+        body: str,
+        attachments: list[dict[str, str]],
+        reply_to_thread_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Send an outbound message with attachments.
+
+        Args:
+            inbox_id: The inbox ID to send from.
+            to: List of recipient email addresses.
+            subject: Email subject.
+            body: Markdown body content.
+            attachments: List of attachment dicts with filename, content_type, content (base64).
+            reply_to_thread_id: Thread ID if this is a reply.
+
+        Returns:
+            Send response with message_id, thread_id, status.
+        """
+        client = await self._get_client()
+        payload: dict[str, Any] = {
+            "inbox_id": inbox_id,
+            "to": to,
+            "subject": subject,
+            "body": body,
+            "attachments": [
+                {
+                    "filename": att["filename"],
+                    "content_type": att["content_type"],
+                    "content_base64": att["content"],
+                }
+                for att in attachments
+            ],
+        }
+        if reply_to_thread_id:
+            payload["reply_to_thread_id"] = reply_to_thread_id
+
+        response = await client.post("/v1/messages", json=payload)
+        response.raise_for_status()
+        return cast("dict[str, Any]", response.json())

{nornweave-0.1.3 → nornweave-0.1.4}/src/nornweave/huginn/resources.py

@@ -52,6 +52,7 @@ async def get_recent_threads(client: NornWeaveClient, inbox_id: str) -> str:
                     "last_message_at": thread.get("last_message_at"),
                     "message_count": message_count,
                     "participants": participants,
+                    "summary": thread.get("summary"),
                 }
             )
 
@@ -114,6 +115,14 @@ def format_thread_markdown(thread: dict[str, Any]) -> str:
     lines.append(f"## Thread: {subject}")
     lines.append("")
 
+    # Include summary if available
+    summary = thread.get("summary")
+    if summary:
+        lines.append("## Summary")
+        lines.append("")
+        lines.append(summary)
+        lines.append("")
+
     messages = thread.get("messages", [])
     if not messages:
         lines.append("*No messages in this thread.*")