rossum-mcp 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

rossum_mcp/tools/email_templates.py

@@ -0,0 +1,131 @@
+"""Email template tools for Rossum MCP Server."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Literal
+
+from rossum_api.models.email_template import EmailTemplate
+
+from rossum_mcp.tools.base import is_read_write_mode
+
+if TYPE_CHECKING:
+    from fastmcp import FastMCP
+    from rossum_api import AsyncRossumAPIClient
+
+logger = logging.getLogger(__name__)
+
+EmailTemplateType = Literal["rejection", "rejection_default", "email_with_no_processable_attachments", "custom"]
+
+
+async def _get_email_template(client: AsyncRossumAPIClient, email_template_id: int) -> EmailTemplate:
+    email_template: EmailTemplate = await client.retrieve_email_template(email_template_id)
+    return email_template
+
+
+async def _list_email_templates(
+    client: AsyncRossumAPIClient,
+    queue_id: int | None = None,
+    type: EmailTemplateType | None = None,
+    name: str | None = None,
+    first_n: int | None = None,
+) -> list[EmailTemplate]:
+    filters: dict = {}
+    if queue_id is not None:
+        filters["queue"] = queue_id
+    if type is not None:
+        filters["type"] = type
+    if name is not None:
+        filters["name"] = name
+
+    if first_n is not None:
+        templates_iter = client.list_email_templates(**filters)
+        templates_list: list[EmailTemplate] = []
+        n = 0
+        while n < first_n:
+            templates_list.append(await anext(templates_iter))
+            n += 1
+    else:
+        templates_list = [template async for template in client.list_email_templates(**filters)]
+
+    return templates_list
+
+
+async def _create_email_template(
+    client: AsyncRossumAPIClient,
+    name: str,
+    queue: str,
+    subject: str,
+    message: str,
+    type: EmailTemplateType = "custom",
+    automate: bool = False,
+    to: list[dict[str, Any]] | None = None,
+    cc: list[dict[str, Any]] | None = None,
+    bcc: list[dict[str, Any]] | None = None,
+    triggers: list[str] | None = None,
+) -> EmailTemplate | dict:
+    if not is_read_write_mode():
+        return {"error": "create_email_template is not available in read-only mode"}
+
+    logger.debug(f"Creating email template: name={name}, queue={queue}, type={type}")
+
+    template_data: dict[str, Any] = {
+        "name": name,
+        "queue": queue,
+        "subject": subject,
+        "message": message,
+        "type": type,
+        "automate": automate,
+    }
+
+    if to is not None:
+        template_data["to"] = to
+    if cc is not None:
+        template_data["cc"] = cc
+    if bcc is not None:
+        template_data["bcc"] = bcc
+    if triggers is not None:
+        template_data["triggers"] = triggers
+
+    email_template: EmailTemplate = await client.create_new_email_template(template_data)
+    return email_template
+
+
+def register_email_template_tools(mcp: FastMCP, client: AsyncRossumAPIClient) -> None:
+    """Register email template-related tools with the FastMCP server."""
+
+    @mcp.tool(
+        description="Retrieve a single email template by ID. Use list_email_templates first to find templates for a queue."
+    )
+    async def get_email_template(email_template_id: int) -> EmailTemplate:
+        return await _get_email_template(client, email_template_id)
+
+    @mcp.tool(
+        description="List all email templates with optional filtering. Email templates define automated or manual email responses sent from Rossum queues. Types: 'rejection' (for rejecting documents), 'rejection_default' (default rejection template), 'email_with_no_processable_attachments' (when email has no valid attachments), 'custom' (user-defined templates)."
+    )
+    async def list_email_templates(
+        queue_id: int | None = None,
+        type: EmailTemplateType | None = None,
+        name: str | None = None,
+        first_n: int | None = None,
+    ) -> list[EmailTemplate]:
+        return await _list_email_templates(client, queue_id, type, name, first_n)
+
+    @mcp.tool(
+        description="Create a new email template. Email templates can be automated (automate=True) to send emails automatically on specific triggers, or manual for user-initiated sending. The 'to', 'cc', and 'bcc' fields accept lists of recipient objects with 'type' ('annotator', 'constant', 'datapoint') and 'value' keys."
+    )
+    async def create_email_template(
+        name: str,
+        queue: str,
+        subject: str,
+        message: str,
+        type: EmailTemplateType = "custom",
+        automate: bool = False,
+        to: list[dict[str, Any]] | None = None,
+        cc: list[dict[str, Any]] | None = None,
+        bcc: list[dict[str, Any]] | None = None,
+        triggers: list[str] | None = None,
+    ) -> EmailTemplate | dict:
+        return await _create_email_template(
+            client, name, queue, subject, message, type, automate, to, cc, bcc, triggers
+        )

rossum_mcp/tools/engines.py

@@ -3,14 +3,10 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, cast
 
 from rossum_api.domain_logic.resources import Resource
-from rossum_api.models.engine import (
-    Engine,  # noqa: TC002 - needed at runtime for FastMCP
-    EngineField,  # noqa: TC002 - needed at runtime for FastMCP
-    EngineFieldType,  # noqa: TC002 - needed at runtime for FastMCP
-)
+from rossum_api.models.engine import Engine, EngineField, EngineFieldType
 
 from rossum_mcp.tools.base import build_resource_url, is_read_write_mode
 
@@ -23,62 +19,124 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-def register_engine_tools(mcp: FastMCP, client: AsyncRossumAPIClient) -> None:  # noqa: C901
+async def _get_engine(client: AsyncRossumAPIClient, engine_id: int) -> Engine:
+    logger.debug(f"Retrieving engine: engine_id={engine_id}")
+    engine: Engine = await client.retrieve_engine(engine_id)
+    return engine
+
+
+async def _list_engines(
+    client: AsyncRossumAPIClient,
+    id: int | None = None,
+    engine_type: EngineType | None = None,
+    agenda_id: str | None = None,
+) -> list[Engine]:
+    logger.debug(f"Listing engines: id={id}, type={engine_type}, agenda_id={agenda_id}")
+    filters: dict[str, int | str] = {}
+    if id is not None:
+        filters["id"] = id
+    if engine_type is not None:
+        filters["type"] = engine_type
+    if agenda_id is not None:
+        filters["agenda_id"] = agenda_id
+    return [engine async for engine in client.list_engines(**filters)]  # type: ignore[arg-type]
+
+
+async def _update_engine(client: AsyncRossumAPIClient, engine_id: int, engine_data: dict) -> Engine | dict:
+    if not is_read_write_mode():
+        return {"error": "update_engine is not available in read-only mode"}
+
+    logger.debug(f"Updating engine: engine_id={engine_id}, data={engine_data}")
+    updated_engine_data = await client._http_client.update(Resource.Engine, engine_id, engine_data)
+    return cast("Engine", client._deserializer(Resource.Engine, updated_engine_data))
+
+
+async def _create_engine(
+    client: AsyncRossumAPIClient, name: str, organization_id: int, engine_type: EngineType
+) -> Engine | dict:
+    if not is_read_write_mode():
+        return {"error": "create_engine is not available in read-only mode"}
+
+    if engine_type not in ("extractor", "splitter"):
+        raise ValueError(f"Invalid engine_type '{engine_type}'. Must be 'extractor' or 'splitter'")
+
+    logger.debug(f"Creating engine: name={name}, organization_id={organization_id}, type={engine_type}")
+    engine_data = {
+        "name": name,
+        "organization": build_resource_url("organizations", organization_id),
+        "type": engine_type,
+    }
+    engine_response = await client._http_client.create(Resource.Engine, engine_data)
+    return cast("Engine", client._deserializer(Resource.Engine, engine_response))
+
+
+async def _create_engine_field(
+    client: AsyncRossumAPIClient,
+    engine_id: int,
+    name: str,
+    label: str,
+    field_type: EngineFieldType,
+    schema_ids: list[int],
+    tabular: bool = False,
+    multiline: str = "false",
+    subtype: str | None = None,
+    pre_trained_field_id: str | None = None,
+) -> EngineField | dict:
+    if not is_read_write_mode():
+        return {"error": "create_engine_field is not available in read-only mode"}
+
+    valid_types = ("string", "number", "date", "enum")
+    if field_type not in valid_types:
+        raise ValueError(f"Invalid field_type '{field_type}'. Must be one of: {', '.join(valid_types)}")
+    if not schema_ids:
+        raise ValueError("schema_ids cannot be empty - engine field must be linked to at least one schema")
+
+    logger.debug(f"Creating engine field: engine_id={engine_id}, name={name}, type={field_type}, schemas={schema_ids}")
+    engine_field_data = {
+        "engine": build_resource_url("engines", engine_id),
+        "name": name,
+        "label": label,
+        "type": field_type,
+        "tabular": tabular,
+        "multiline": multiline,
+        "schemas": [build_resource_url("schemas", schema_id) for schema_id in schema_ids],
+    }
+    if subtype is not None:
+        engine_field_data["subtype"] = subtype
+    if pre_trained_field_id is not None:
+        engine_field_data["pre_trained_field_id"] = pre_trained_field_id
+
+    engine_field_response = await client._http_client.create(Resource.EngineField, engine_field_data)
+    return cast("EngineField", client._deserializer(Resource.EngineField, engine_field_response))
+
+
+async def _get_engine_fields(client: AsyncRossumAPIClient, engine_id: int | None = None) -> list[EngineField]:
+    logger.debug(f"Retrieving engine fields: engine_id={engine_id}")
+    return [engine_field async for engine_field in client.retrieve_engine_fields(engine_id=engine_id)]
+
+
+def register_engine_tools(mcp: FastMCP, client: AsyncRossumAPIClient) -> None:
     """Register engine-related tools with the FastMCP server."""
 
     @mcp.tool(description="Retrieve a single engine by ID.")
     async def get_engine(engine_id: int) -> Engine:
-        """Retrieve a single engine by ID."""
-        logger.debug(f"Retrieving engine: engine_id={engine_id}")
-        engine: Engine = await client.retrieve_engine(engine_id)
-        return engine
+        return await _get_engine(client, engine_id)
 
     @mcp.tool(description="List all engines with optional filters.")
     async def list_engines(
         id: int | None = None, engine_type: EngineType | None = None, agenda_id: str | None = None
     ) -> list[Engine]:
-        """List all engines with optional filters."""
-        logger.debug(f"Listing engines: id={id}, type={engine_type}, agenda_id={agenda_id}")
-        filters: dict[str, int | str] = {}
-        if id is not None:
-            filters["id"] = id
-        if engine_type is not None:
-            filters["type"] = engine_type
-        if agenda_id is not None:
-            filters["agenda_id"] = agenda_id
-        return [engine async for engine in client.list_engines(**filters)]  # type: ignore[arg-type]
+        return await _list_engines(client, id, engine_type, agenda_id)
 
     @mcp.tool(description="Update engine settings.")
     async def update_engine(engine_id: int, engine_data: dict) -> Engine | dict:
-        """Update an existing engine's settings."""
-        if not is_read_write_mode():
-            return {"error": "update_engine is not available in read-only mode"}
-
-        logger.debug(f"Updating engine: engine_id={engine_id}, data={engine_data}")
-        updated_engine_data = await client._http_client.update(Resource.Engine, engine_id, engine_data)
-        updated_engine: Engine = client._deserializer(Resource.Engine, updated_engine_data)
-        return updated_engine
+        return await _update_engine(client, engine_id, engine_data)
 
     @mcp.tool(
         description="Create a new engine. IMPORTANT: When creating a new engine, check the schema to be used and create contained Engine fields immediately!"
     )
     async def create_engine(name: str, organization_id: int, engine_type: EngineType) -> Engine | dict:
-        """Create a new engine."""
-        if not is_read_write_mode():
-            return {"error": "create_engine is not available in read-only mode"}
-
-        if engine_type not in ("extractor", "splitter"):
-            raise ValueError(f"Invalid engine_type '{engine_type}'. Must be 'extractor' or 'splitter'")
-
-        logger.debug(f"Creating engine: name={name}, organization_id={organization_id}, type={engine_type}")
-        engine_data = {
-            "name": name,
-            "organization": build_resource_url("organizations", organization_id),
-            "type": engine_type,
-        }
-        engine_response = await client._http_client.create(Resource.Engine, engine_data)
-        engine: Engine = client._deserializer(Resource.Engine, engine_response)
-        return engine
+        return await _create_engine(client, name, organization_id, engine_type)
 
     @mcp.tool(description="Create engine field for each schema field. Must be called when creating engine + schema.")
     async def create_engine_field(
@@ -92,39 +150,10 @@ def register_engine_tools(mcp: FastMCP, client: AsyncRossumAPIClient) -> None:
         subtype: str | None = None,
         pre_trained_field_id: str | None = None,
     ) -> EngineField | dict:
-        """Create a new engine field and link it to schemas."""
-        if not is_read_write_mode():
-            return {"error": "create_engine_field is not available in read-only mode"}
-
-        valid_types = ("string", "number", "date", "enum")
-        if field_type not in valid_types:
-            raise ValueError(f"Invalid field_type '{field_type}'. Must be one of: {', '.join(valid_types)}")
-        if not schema_ids:
-            raise ValueError("schema_ids cannot be empty - engine field must be linked to at least one schema")
-
-        logger.debug(
-            f"Creating engine field: engine_id={engine_id}, name={name}, type={field_type}, schemas={schema_ids}"
+        return await _create_engine_field(
+            client, engine_id, name, label, field_type, schema_ids, tabular, multiline, subtype, pre_trained_field_id
         )
-        engine_field_data = {
-            "engine": build_resource_url("engines", engine_id),
-            "name": name,
-            "label": label,
-            "type": field_type,
-            "tabular": tabular,
-            "multiline": multiline,
-            "schemas": [build_resource_url("schemas", schema_id) for schema_id in schema_ids],
-        }
-        if subtype is not None:
-            engine_field_data["subtype"] = subtype
-        if pre_trained_field_id is not None:
-            engine_field_data["pre_trained_field_id"] = pre_trained_field_id
-
-        engine_field_response = await client._http_client.create(Resource.EngineField, engine_field_data)
-        engine_field: EngineField = client._deserializer(Resource.EngineField, engine_field_response)
-        return engine_field
 
     @mcp.tool(description="Retrieve engine fields for a specific engine or all engine fields.")
     async def get_engine_fields(engine_id: int | None = None) -> list[EngineField]:
-        """Retrieve engine fields for a specific engine or all engine fields."""
-        logger.debug(f"Retrieving engine fields: engine_id={engine_id}")
-        return [engine_field async for engine_field in client.retrieve_engine_fields(engine_id=engine_id)]
+        return await _get_engine_fields(client, engine_id)