rossum-agent 1.0.0rc0__py3-none-any.whl

rossum_agent/api/services/chat_service.py

@@ -0,0 +1,197 @@
+"""Chat service for managing chat sessions."""
+
+from __future__ import annotations
+
+import datetime as dt
+import logging
+import secrets
+from typing import TYPE_CHECKING
+
+from rossum_agent.api.models.schemas import (
+    ChatDetail,
+    ChatListResponse,
+    ChatResponse,
+    ChatSummary,
+    FileInfo,
+    Message,
+)
+from rossum_agent.redis_storage import ChatData, ChatMetadata, RedisStorage
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Any, Literal
+
+logger = logging.getLogger(__name__)
+
+
+class ChatService:
+    """Service for managing chat sessions.
+
+    Wraps RedisStorage to provide chat CRUD operations with proper
+    data transformation to/from API schemas.
+    """
+
+    def __init__(self, redis_storage: RedisStorage | None = None) -> None:
+        self._storage = redis_storage or RedisStorage()
+
+    @property
+    def storage(self) -> RedisStorage:
+        """Get the underlying RedisStorage instance."""
+        return self._storage
+
+    def is_connected(self) -> bool:
+        """Check if Redis is connected."""
+        return self._storage.is_connected()
+
+    def create_chat(
+        self, user_id: str | None, mcp_mode: Literal["read-only", "read-write"] = "read-only"
+    ) -> ChatResponse:
+        """Create a new chat session.
+
+        Args:
+            user_id: User identifier for isolation.
+            mcp_mode: MCP mode for this chat session.
+
+        Returns:
+            ChatResponse with the new chat_id and created_at timestamp.
+        """
+        timestamp = dt.datetime.now(dt.UTC)
+        timestamp_str = timestamp.strftime("%Y%m%d%H%M%S")
+        unique_suffix = secrets.token_hex(4)
+        chat_id = f"chat_{timestamp_str}_{unique_suffix}"
+
+        initial_messages: list[dict[str, Any]] = []
+        metadata = ChatMetadata(mcp_mode=mcp_mode)
+        self._storage.save_chat(user_id, chat_id, initial_messages, metadata=metadata)
+
+        logger.info(f"Created chat {chat_id} for user {user_id or 'shared'} with mcp_mode={mcp_mode}")
+        return ChatResponse(chat_id=chat_id, created_at=timestamp)
+
+    def list_chats(self, user_id: str | None, limit: int = 50, offset: int = 0) -> ChatListResponse:
+        """List chat sessions for a user.
+
+        Args:
+            user_id: User identifier for isolation.
+            limit: Maximum number of chats to return.
+            offset: Pagination offset.
+
+        Returns:
+            ChatListResponse with paginated chat list.
+        """
+        all_chats = self._storage.list_all_chats(user_id)
+
+        paginated = all_chats[offset : offset + limit]
+        chats = [
+            ChatSummary(
+                chat_id=chat["chat_id"],
+                timestamp=chat["timestamp"],
+                message_count=chat["message_count"],
+                first_message=chat["first_message"],
+                preview=chat.get("preview"),
+            )
+            for chat in paginated
+        ]
+
+        return ChatListResponse(chats=chats, total=len(all_chats), limit=limit, offset=offset)
+
+    def get_chat(self, user_id: str | None, chat_id: str) -> ChatDetail | None:
+        """Get detailed chat information.
+
+        Args:
+            user_id: User identifier for isolation.
+            chat_id: Chat session identifier.
+
+        Returns:
+            ChatDetail with messages and files, or None if not found.
+        """
+        if (chat_data := self._storage.load_chat(user_id, chat_id)) is None:
+            return None
+
+        messages = []
+        for msg in chat_data.messages:
+            msg_type = msg.get("type")
+            role = msg.get("role")
+
+            if msg_type == "task_step":
+                task_content = msg.get("task", "")
+                messages.append(Message(role="user", content=task_content))
+            elif msg_type == "memory_step":
+                text = msg.get("text")
+                if text:
+                    messages.append(Message(role="assistant", content=text))
+            elif role in ("user", "assistant"):
+                messages.append(Message(role=role, content=msg.get("content", "")))
+
+        files_data = self._storage.list_files(chat_id)
+        files = [FileInfo(filename=f["filename"], size=f["size"], timestamp=f["timestamp"]) for f in files_data]
+
+        timestamp_str = chat_id.split("_")[1]
+        created_at = dt.datetime.strptime(timestamp_str, "%Y%m%d%H%M%S").replace(tzinfo=dt.UTC)
+
+        return ChatDetail(chat_id=chat_id, messages=messages, created_at=created_at, files=files)
+
+    def delete_chat(self, user_id: str | None, chat_id: str) -> bool:
+        """Delete a chat session.
+
+        Args:
+            user_id: User identifier for isolation.
+            chat_id: Chat session identifier.
+
+        Returns:
+            True if deleted, False otherwise.
+        """
+        self._storage.delete_all_files(chat_id)
+        deleted = self._storage.delete_chat(user_id, chat_id)
+        logger.info(f"Deleted chat {chat_id} for user {user_id or 'shared'}: {deleted}")
+        return deleted
+
+    def chat_exists(self, user_id: str | None, chat_id: str) -> bool:
+        """Check if a chat exists.
+
+        Args:
+            user_id: User identifier for isolation.
+            chat_id: Chat session identifier.
+        """
+        return self._storage.chat_exists(user_id, chat_id)
+
+    def get_messages(self, user_id: str | None, chat_id: str) -> list[dict[str, Any]] | None:
+        """Get raw messages for a chat session.
+
+        Args:
+            user_id: User identifier for isolation.
+            chat_id: Chat session identifier.
+        """
+        if (chat_data := self._storage.load_chat(user_id, chat_id)) is None:
+            return None
+        return chat_data.messages
+
+    def get_chat_data(self, user_id: str | None, chat_id: str) -> ChatData | None:
+        """Get full chat data including metadata.
+
+        Args:
+            user_id: User identifier for isolation.
+            chat_id: Chat session identifier.
+        """
+        return self._storage.load_chat(user_id, chat_id)
+
+    def save_messages(
+        self,
+        user_id: str | None,
+        chat_id: str,
+        messages: list[dict[str, Any]],
+        output_dir: Path | None = None,
+        metadata: ChatMetadata | None = None,
+    ) -> bool:
+        """Save messages to a chat session.
+
+        Args:
+            user_id: User identifier for isolation.
+            chat_id: Chat session identifier.
+            messages: List of message dicts to save.
+            output_dir: Optional output directory path.
+            metadata: Optional chat metadata with token counts and step info.
+
+        Returns:
+            True if saved successfully, False otherwise.
+        """
+        return self._storage.save_chat(user_id, chat_id, messages, output_dir, metadata)

rossum_agent/api/services/file_service.py

@@ -0,0 +1,65 @@
+"""File service for managing chat session files."""
+
+from __future__ import annotations
+
+import mimetypes
+
+from rossum_agent.api.models.schemas import FileInfo
+from rossum_agent.redis_storage import RedisStorage
+
+
+class FileService:
+    """Service for managing files associated with chat sessions.
+
+    Wraps RedisStorage file operations with proper validation and
+    data transformation to/from API schemas.
+    """
+
+    def __init__(self, redis_storage: RedisStorage | None = None) -> None:
+        self._storage = redis_storage or RedisStorage()
+
+    @property
+    def storage(self) -> RedisStorage:
+        """Get the underlying RedisStorage instance."""
+        return self._storage
+
+    def list_files(self, chat_id: str) -> list[FileInfo]:
+        """List all files for a chat session.
+
+        Args:
+            chat_id: Chat session identifier.
+
+        Returns:
+            List of FileInfo objects with file metadata.
+        """
+        files_data = self._storage.list_files(chat_id)
+        return [
+            FileInfo(
+                filename=f["filename"],
+                size=f["size"],
+                timestamp=f["timestamp"],
+                mime_type=self._guess_mime_type(f["filename"]),
+            )
+            for f in files_data
+        ]
+
+    def get_file(self, chat_id: str, filename: str) -> tuple[bytes, str] | None:
+        """Get file content and MIME type.
+
+        Args:
+            chat_id: Chat session identifier.
+            filename: Name of the file.
+
+        Returns:
+            Tuple of (content bytes, mime_type) or None if not found.
+        """
+        if (content := self._storage.load_file(chat_id, filename)) is None:
+            return None
+
+        mime_type = self._guess_mime_type(filename)
+        return content, mime_type
+
+    def _guess_mime_type(self, filename: str) -> str:
+        """Guess MIME type from filename."""
+        mime_type, _ = mimetypes.guess_type(filename)
+        return mime_type or "application/octet-stream"

rossum_agent/bedrock_client.py

@@ -0,0 +1,64 @@
+"""AWS Bedrock client module for direct communication with Anthropic models via boto3.Session."""
+
+from __future__ import annotations
+
+import os
+
+import boto3
+from anthropic import AnthropicBedrock
+
+OPUS_MODEL_ID = "eu.anthropic.claude-opus-4-5-20251101-v1:0"
+HAIKU_MODEL_ID = "eu.anthropic.claude-haiku-4-5-20251001-v1:0"
+
+
+def create_bedrock_client(
+    aws_region: str | None = None, aws_profile: str | None = None, session: boto3.Session | None = None
+) -> AnthropicBedrock:
+    """Create AnthropicBedrock client using boto3.Session credentials.
+
+    This function supports multiple credential sources:
+    1. Explicit boto3.Session passed as argument
+    2. AWS profile name (uses named profile from ~/.aws/credentials)
+    3. Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN)
+    4. IAM role credentials (when running on AWS infrastructure)
+
+    Args:
+        aws_region: AWS region for Bedrock service. Defaults to AWS_REGION env var
+            or 'eu-central-1'.
+        aws_profile: AWS profile name from ~/.aws/credentials. Overridden if session
+            is provided.
+        session: Pre-configured boto3.Session. If provided, aws_profile is ignored.
+
+    Returns:
+        Configured AnthropicBedrock client ready for API calls.
+    """
+    region = aws_region or os.environ.get("AWS_REGION")
+
+    if session is None:
+        session = boto3.Session(profile_name=aws_profile, region_name=region)
+
+    if (credentials := session.get_credentials()) is None:
+        raise RuntimeError(
+            "No AWS credentials found. Please configure AWS credentials via environment "
+            "variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY), AWS profile, or IAM role."
+        )
+
+    frozen_credentials = credentials.get_frozen_credentials()
+
+    return AnthropicBedrock(
+        aws_access_key=frozen_credentials.access_key,
+        aws_secret_key=frozen_credentials.secret_key,
+        aws_session_token=frozen_credentials.token,
+        aws_region=session.region_name or region,
+        max_retries=5,
+    )
+
+
+def get_model_id() -> str:
+    """Return AWS_BEDROCK_MODEL_ARN if set, otherwise default Opus model."""
+    return os.environ.get("AWS_BEDROCK_MODEL_ARN", OPUS_MODEL_ID)
+
+
+def get_small_model_id() -> str:
+    """Return AWS_BEDROCK_MODEL_ARN_SMALL if set, otherwise default Haiku model."""
+    return os.environ.get("AWS_BEDROCK_MODEL_ARN_SMALL", HAIKU_MODEL_ID)

rossum_agent/prompts/__init__.py

@@ -0,0 +1,27 @@
+"""Prompt templates for the Rossum Agent.
+
+This package contains shared prompt content and specialized prompt builders
+for different agent paradigms (tool-use, code-execution).
+"""
+
+from __future__ import annotations
+
+from rossum_agent.prompts.base_prompt import (
+    CONFIGURATION_WORKFLOWS,
+    CRITICAL_REQUIREMENTS,
+    DOCUMENTATION_WORKFLOWS,
+    OUTPUT_FORMATTING,
+    ROSSUM_EXPERT_INTRO,
+    get_shared_prompt_sections,
+)
+from rossum_agent.prompts.system_prompt import get_system_prompt
+
+__all__ = [
+    "CONFIGURATION_WORKFLOWS",
+    "CRITICAL_REQUIREMENTS",
+    "DOCUMENTATION_WORKFLOWS",
+    "OUTPUT_FORMATTING",
+    "ROSSUM_EXPERT_INTRO",
+    "get_shared_prompt_sections",
+    "get_system_prompt",
+]

rossum_agent/prompts/base_prompt.py

@@ -0,0 +1,80 @@
+"""Shared prompt content for the Rossum Agent.
+
+Optimized for Opus 4.5: Goals + constraints, not procedures.
+"""
+
+from __future__ import annotations
+
+ROSSUM_EXPERT_INTRO = """You are an expert Rossum platform specialist. Help users understand, document, debug, and configure document processing workflows.
+
+**CRITICAL - Use `search_knowledge_base` before**:
+- Explaining ANY extension/hook behavior (except simple function hooks you can read directly)
+- Debugging issues - knowledge base contains known issues and solutions
+- Configuring extensions - knowledge base has required settings and examples
+
+**Skills** (load FIRST when relevant):
+- `load_skill("rossum-deployment")` → sandbox, deploy, cross-org, migrate
+- `load_skill("hook-debugging")` → debug/fix function hooks
+- `load_skill("organization-setup")` → new customer onboarding, queue templates
+- `load_skill("schema-patching")` → modify schemas, add/remove fields, formulas
+- `load_skill("schema-pruning")` → bulk remove unwanted fields from schema
+- `load_skill("ui-settings")` → update queue UI settings, annotation list columns
+
+**MCP Tools** (pre-loaded based on request keywords, or load manually):
+- `load_tool_category(["queues", "schemas"])` to load multiple categories at once
+- Categories: annotations, queues, schemas, engines, hooks, email_templates, document_relations, relations, rules, users, workspaces"""
+
+CRITICAL_REQUIREMENTS = """
+# Domain Knowledge
+
+**Schema**: sections → datapoints | multivalues → tuples (tables). Datapoint fields: `id`, `label`, `type`, `is_formula`, `formula`, `is_reasoning`, `prompt`, `score_threshold`.
+
+**API constraints**:
+- IDs are integers: `queue_id=12345` not `"12345"`
+- `score_threshold` cannot be null (default `0.8`) - API rejects null values
+- Annotation updates use numeric `id`, not `schema_id` string
+
+**Engine training**: Inbox queues cannot train classification engines - they contain unsplit documents without `document_type`. Only typed documents in training_queues contribute."""
+
+DOCUMENTATION_WORKFLOWS = """
+# Visual Documentation
+
+Use Mermaid diagrams for workflows. Apply this styling:
+
+```mermaid
+graph TD
+    Start[Document Upload]
+    Start --> Event1["annotation_status<br/>2 hooks"]
+    style Event1 fill:#E8F4F8,stroke:#4A90E2,stroke-width:2px
+    Event1 --> Hook1["Validation Hook<br/>[function]"]
+    style Hook1 fill:#4A90E2,stroke:#2E5C8A,color:#fff
+    Event1 --> End[Complete]
+
+    click Event1 "#annotation_status"
+    click Hook1 "#validation_hook"
+```
+
+Event nodes: light blue (`#E8F4F8`). Hook nodes: darker blue (`#4A90E2`, white text). Add clickable anchors."""
+
+CONFIGURATION_WORKFLOWS = """
+# Configuration
+
+**Sandbox deployments**: Load `rossum-deployment` skill first. Execute autonomously through diff, then wait for user approval before deploying.
+
+**Direct operations**: For single-org changes without sandbox, use MCP tools directly.
+
+**Hooks**: Prefer `list_hook_templates` + `create_hook_from_template` over custom code."""
+
+OUTPUT_FORMATTING = """
+# Output
+
+Match response length to question complexity. Be concise for simple questions.
+
+For documentation: use Mermaid diagrams, cross-reference with anchors, explain business logic in prose (not JSON dumps), flag issues with `⚠️ SUSPICIOUS:`."""
+
+
+def get_shared_prompt_sections() -> str:
+    """Get all shared prompt sections combined."""
+    return "\n\n---\n".join(
+        [CRITICAL_REQUIREMENTS, DOCUMENTATION_WORKFLOWS, CONFIGURATION_WORKFLOWS, OUTPUT_FORMATTING]
+    )

rossum_agent/prompts/system_prompt.py

@@ -0,0 +1,24 @@
+"""System prompt for the RossumAgent using Anthropic's tool use API.
+
+This module provides the system prompt that defines the agent's behavior,
+capabilities, and guidelines for interacting with the Rossum platform.
+The prompt is adapted for use with Anthropic's native tool use API.
+"""
+
+from __future__ import annotations
+
+from rossum_agent.prompts.base_prompt import ROSSUM_EXPERT_INTRO, get_shared_prompt_sections
+
+SYSTEM_PROMPT = f"""{ROSSUM_EXPERT_INTRO}
+
+---
+{get_shared_prompt_sections()}"""
+
+
+def get_system_prompt() -> str:
+    """Get the system prompt for the RossumAgent.
+
+    Returns:
+        The system prompt string defining agent behavior.
+    """
+    return SYSTEM_PROMPT