Skip to main content
Glama

get_invite_status

Check the status of signing invitations for documents or document groups in SignNow. Use this tool to monitor invite progress and track signature completion.

Instructions

Get invite status for a document or document group

Note: If your client supports MCP Resources, prefer the resource version of this endpoint; this tool exists as a compatibility fallback for tool-only clients.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
entity_idYesID of the document or document group
entity_typeNoType of entity: 'document' or 'document_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.

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
stepsYesList of steps in the invite
statusYesOverall invite status: 'created', 'pending', 'fulfilled'
invite_idYesID of the invite

Implementation Reference

  • MCP tool handler function for 'get_invite_status'. Includes registration decorator, input schema via Annotated Fields, and delegates to internal implementation.
    @mcp.tool(name="get_invite_status", description="Get invite status for a document or document group" + TOOL_FALLBACK_SUFFIX, tags=["invite", "status", "document", "document_group", "workflow"])
    def get_invite_status(
        ctx: Context,
        entity_id: Annotated[str, Field(description="ID of the document or document group")],
        entity_type: Annotated[
            Literal["document", "document_group"] | None,
            Field(description="Type of entity: 'document' or 'document_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,
    ) -> InviteStatus:
        return _get_invite_status_impl(ctx, entity_id, entity_type)
  • Helper function that obtains authentication token and client, then calls the core _get_invite_status logic.
    def _get_invite_status_impl(ctx: Context, entity_id: str, entity_type: Literal["document", "document_group"] | None) -> InviteStatus:
        token, client = _get_token_and_client(token_provider)
        return _get_invite_status(entity_id, entity_type, token, client)
  • Core implementation of invite status retrieval. Determines entity type if needed, fetches document or document group via SignNow API, and constructs InviteStatus object using helper functions _get_document_status or _get_document_group_status.
    def _get_invite_status(entity_id: str, entity_type: Literal["document", "document_group"] | None, token: str, client: SignNowAPIClient) -> InviteStatus:
        """Private function to get invite status for a document or document group.
    
        Args:
            entity_id: ID of the document or document group
            entity_type: Type of entity: 'document' or 'document_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.
            token: Access token for SignNow API
            client: SignNow API client instance
    
        Returns:
            InviteStatus with invite ID, status, and steps information
        """
        # Determine entity type if not provided and get entity data
        document_group = None
        document = None
    
        if not entity_type:
            # Try to determine entity type by attempting to get document group first (higher priority)
            try:
                document_group = client.get_document_group_v2(token, entity_id)
                entity_type = "document_group"
            except Exception:
                # If document group not found, try document
                try:
                    document = client.get_document(token, entity_id)
                    entity_type = "document"
                except Exception:
                    raise ValueError(f"Entity with ID {entity_id} not found as either document group or document") from None
        else:
            # Entity type is provided, get the entity data
            if entity_type == "document_group":
                document_group = client.get_document_group_v2(token, entity_id)
            else:
                document = client.get_document(token, entity_id)
    
        if entity_type == "document_group":
            # Get document group status using the already fetched data
            return _get_document_group_status(client, token, document_group, entity_id)
        else:
            # Get document status using the already fetched data
            return _get_document_status(client, token, document)
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool is a 'compatibility fallback,' which hints at its role but doesn't describe key behaviors like whether it's a read-only operation, what the output format is, error handling, or any rate limits. For a tool with no annotations, this leaves significant gaps in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured: the first sentence states the purpose, and the second provides critical usage guidance. Both sentences earn their place by adding value, with no wasted words or redundancy, making it front-loaded and efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (simple read operation), 100% schema coverage, and the presence of an output schema (which handles return values), the description is largely complete. It covers purpose and usage context effectively. However, it lacks behavioral details like error cases or performance hints, which slightly reduces completeness for a tool with no annotations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the schema already documents both parameters ('entity_id' and 'entity_type') with descriptions. The tool description doesn't add any meaning beyond this, such as explaining parameter interactions or providing examples. According to the rules, with high schema coverage, the baseline is 3, which is appropriate here.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Get invite status for a document or document group.' It uses a specific verb ('Get') and resource ('invite status'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'send_invite' or 'create_embedded_invite' beyond the 'get' vs. 'send/create' distinction, which is why it doesn't reach a score of 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit usage guidance: it advises preferring the MCP Resource version if available and positions this tool as a 'compatibility fallback for tool-only clients.' This clearly indicates when to use this tool (for compatibility) versus alternatives (the resource version), meeting the criteria for a score of 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/signnow/sn-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server