SignNow MCP Server

Instructions

Implementation Reference

• src/sn_mcp_server/tools/signnow.py:404-456 (handler)

  MCP tool registration and handler function for send_invite_from_template. Normalizes orders, gets auth token, and delegates to core implementation.

  @mcp.tool(
      name="send_invite_from_template",
      description=(
          "Create document/group from template and send invite immediately. "
          "This tool is ONLY for templates and template groups. "
          "If you have document or document_group, use the alternative tool: send_invite"
      ),
      tags=["template", "template_group", "document", "document_group", "send_invite", "workflow"],
  )
  async def send_invite_from_template(
      ctx: Context,
      entity_id: Annotated[str, Field(description="ID of the template or template group")],
      orders: Annotated[
          list[InviteOrder] | str,
          Field(
              description="List of orders with recipients for the invite (can be a list or JSON string)",
              examples=[
                  [{"order": 1, "recipients": [{"email": "user@example.com", "role": "Signer 1", "action": "sign"}]}],
                  '[{"order": 1, "recipients": [{"email": "user@example.com", "role": "Signer 1", "action": "sign"}]}]',
              ],
          ),
      ],
      entity_type: Annotated[
          Literal["template", "template_group"] | None,
          Field(description="Type of entity: 'template' or 'template_group' (optional). If you're passing it, make sure you know what type you have. If it's not found, try using a different type."),
      ] = None,
      name: Annotated[str | None, Field(description="Optional name for the new document or document group")] = None,
  ) -> SendInviteFromTemplateResponse:
      """Create document or document group from template and send invite immediately.
  
      This tool is ONLY for templates and template groups.
      If you have document or document_group, use the alternative tool: send_invite
  
      This tool combines two operations:
      1. Creates a document/group from template using create_from_template
      2. Sends an invite to the created entity using send_invite
  
      Args:
          entity_id: ID of the template or template group
          orders: List of orders with recipients for the invite (can be a list or JSON string)
          entity_type: Type of entity: 'template' or 'template_group' (optional). If you're passing it, make sure you know what type you have. If it's not found, try using a different type.
          name: Optional name for the new document or document group
  
      Returns:
          SendInviteFromTemplateResponse with created entity info and invite details
      """
      token, client = _get_token_and_client(token_provider)
  
      # Normalize orders parameter (handle JSON string input)
      normalized_orders = _normalize_orders(orders, InviteOrder)
  
      # Initialize client and use the imported function from send_invite module
      return await _send_invite_from_template(entity_id, entity_type, name, normalized_orders, token, client, ctx)

• src/sn_mcp_server/tools/send_invite.py:152-194 (handler)

  Core handler logic: creates document/group from template, sends invite, reports progress using MCP context.

  async def _send_invite_from_template(
      entity_id: str, entity_type: Literal["template", "template_group"] | None, name: str | None, orders: list[InviteOrder], token: str, client: SignNowAPIClient, ctx: Context
  ) -> SendInviteFromTemplateResponse:
      """Private function to create document/group from template and send invite immediately.
  
      Args:
          entity_id: ID of the template or template group
          entity_type: Type of entity: 'template' or 'template_group' (optional). If you're passing it, make sure you know what type you have. If it's not found, try using a different type.
          name: Optional name for the new document or document group
          orders: List of orders with recipients for the invite
          token: Access token for SignNow API
          client: SignNow API client instance
          ctx: FastMCP context for progress reporting
  
      Returns:
          SendInviteFromTemplateResponse with created entity info and invite details
      """
      # Report initial progress
      await ctx.report_progress(progress=1, total=3)
  
      # Import and use the create from template function directly
      from .create_from_template import _create_from_template
  
      # Use the imported function to create from template
      created_entity = _create_from_template(entity_id, entity_type, name, token, client)
  
      # Report progress after template creation
      await ctx.report_progress(progress=2, total=3)
  
      # Then send invite
      invite_response = _send_invite(created_entity.entity_id, created_entity.entity_type or "document", orders, token, client)
  
      # Report final progress after invite sending
      await ctx.report_progress(progress=3, total=3)
  
      return SendInviteFromTemplateResponse(
          created_entity_id=created_entity.entity_id,
          created_entity_type=created_entity.entity_type,
          created_entity_name=created_entity.name,
          invite_id=invite_response.invite_id,
          invite_entity=invite_response.invite_entity,
      )

• src/sn_mcp_server/tools/models.py:223-231 (schema)

  Input schema (SendInviteFromTemplateRequest) defining parameters for the tool.

  class SendInviteFromTemplateRequest(BaseModel):
      """Request model for creating document/group from template and sending invite immediately."""
  
      entity_id: str = Field(..., description="ID of the template or template group")
      entity_type: str | None = Field(None, description="Type of entity: 'template' or 'template_group' (optional)")
      name: str | None = Field(None, description="Optional name for the new document or document group")
      folder_id: str | None = Field(None, description="Optional ID of the folder to store the document group")
      orders: list[InviteOrder] = Field(default=[], description="List of orders with recipients for the invite")

• src/sn_mcp_server/tools/models.py:233-241 (schema)

  Output schema (SendInviteFromTemplateResponse) defining the tool's return type.

  class SendInviteFromTemplateResponse(BaseModel):
      """Response model for creating document/group from template and sending invite immediately."""
  
      created_entity_id: str = Field(..., description="ID of the created document or document group")
      created_entity_type: str = Field(..., description="Type of created entity: 'document' or 'document_group'")
      created_entity_name: str = Field(..., description="Name of the created entity")
      invite_id: str = Field(..., description="ID of the created invite")
      invite_entity: str = Field(..., description="Type of invite entity: 'document' or 'document_group'")