awslabs.stepfunctions-tool-mcp-server 0.1.4__py3-none-any.whl

awslabs/__init__.py

@@ -0,0 +1,2 @@
+# This file is part of the awslabs namespace.
+# It is intentionally minimal to support PEP 420 namespace packages.

awslabs/stepfunctions_tool_mcp_server/__init__.py

@@ -0,0 +1,3 @@
+"""awslabs.stepfunctions-tool-mcp-server"""
+
+__version__ = '0.0.0'

awslabs/stepfunctions_tool_mcp_server/server.py

@@ -0,0 +1,402 @@
+"""awslabs Step Functions Tool MCP Server implementation."""
+
+import asyncio
+import boto3
+import json
+import logging
+import os
+import re
+from mcp.server.fastmcp import Context, FastMCP
+from typing import Optional
+
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+AWS_PROFILE = os.environ.get('AWS_PROFILE', 'default')
+logger.info(f'AWS_PROFILE: {AWS_PROFILE}')
+
+AWS_REGION = os.environ.get('AWS_REGION', 'us-east-1')
+logger.info(f'AWS_REGION: {AWS_REGION}')
+
+STATE_MACHINE_PREFIX = os.environ.get('STATE_MACHINE_PREFIX', '')
+logger.info(f'STATE_MACHINE_PREFIX: {STATE_MACHINE_PREFIX}')
+
+STATE_MACHINE_LIST = [
+    state_machine_name.strip()
+    for state_machine_name in os.environ.get('STATE_MACHINE_LIST', '').split(',')
+    if state_machine_name.strip()
+]
+logger.info(f'STATE_MACHINE_LIST: {STATE_MACHINE_LIST}')
+
+STATE_MACHINE_TAG_KEY = os.environ.get('STATE_MACHINE_TAG_KEY', '')
+logger.info(f'STATE_MACHINE_TAG_KEY: {STATE_MACHINE_TAG_KEY}')
+
+STATE_MACHINE_TAG_VALUE = os.environ.get('STATE_MACHINE_TAG_VALUE', '')
+logger.info(f'STATE_MACHINE_TAG_VALUE: {STATE_MACHINE_TAG_VALUE}')
+
+STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY = os.environ.get('STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY')
+logger.info(f'STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY: {STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY}')
+
+# Initialize AWS clients
+session = boto3.Session(profile_name=AWS_PROFILE, region_name=AWS_REGION)
+sfn_client = session.client('stepfunctions')
+schemas_client = session.client('schemas')
+
+mcp = FastMCP(
+    'awslabs.stepfunctions-tool-mcp-server',
+    instructions="""Use AWS Step Functions state machines to improve your answers.
+    These state machines give you additional capabilities and access to AWS services and resources in an AWS account.""",
+    dependencies=['pydantic', 'boto3'],
+)
+
+
+def validate_state_machine_name(state_machine_name: str) -> bool:
+    """Validate that the state machine name is valid and can be called."""
+    # If both prefix and list are empty, consider all state machines valid
+    if not STATE_MACHINE_PREFIX and not STATE_MACHINE_LIST:
+        return True
+
+    # Otherwise, check if the state machine name matches the prefix or is in the list
+    return (STATE_MACHINE_PREFIX and state_machine_name.startswith(STATE_MACHINE_PREFIX)) or (
+        state_machine_name in STATE_MACHINE_LIST
+    )
+
+
+def sanitize_tool_name(name: str) -> str:
+    """Sanitize a Step Functions state machine name to be used as a tool name."""
+    # Remove prefix if present
+    if name.startswith(STATE_MACHINE_PREFIX):
+        name = name[len(STATE_MACHINE_PREFIX) :]
+
+    # Replace invalid characters with underscore
+    name = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+
+    # Ensure name doesn't start with a number
+    if name and name[0].isdigit():
+        name = '_' + name
+
+    return name
+
+
+def format_state_machine_response(state_machine_name: str, payload: bytes) -> str:
+    """Format the Step Functions state machine response payload."""
+    try:
+        # Try to parse the payload as JSON
+        payload_json = json.loads(payload)
+        return f'State machine {state_machine_name} returned: {json.dumps(payload_json, indent=2)}'
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        # Return raw payload if not JSON
+        return f'State machine {state_machine_name} returned payload: {payload}'
+
+
+async def invoke_standard_state_machine_impl(
+    state_machine_name: str, state_machine_arn: str, parameters: dict, ctx: Context
+) -> str:
+    """Execute a Standard state machine using StartExecution and poll for completion."""
+    await ctx.info(
+        f'Starting asynchronous execution of Standard state machine {state_machine_name}'
+    )
+
+    # Start the execution
+    response = sfn_client.start_execution(
+        stateMachineArn=state_machine_arn,
+        input=json.dumps(parameters),
+    )
+
+    await ctx.info(f'Started execution {response["executionArn"]}')
+
+    # Wait for execution to complete
+    while True:
+        execution = sfn_client.describe_execution(executionArn=response['executionArn'])
+        status = execution['status']
+        await ctx.info(f'Execution status: {status}')
+
+        if status == 'SUCCEEDED':
+            output = execution['output']
+            return format_state_machine_response(state_machine_name, output.encode())
+        elif status in ['FAILED', 'TIMED_OUT', 'ABORTED']:
+            error_message = (
+                f'State machine {state_machine_name} execution failed with status: {status}'
+            )
+            if 'error' in execution:
+                error_message += f', error: {execution["error"]}'
+            if 'cause' in execution:
+                error_message += f', cause: {execution["cause"]}'
+            await ctx.error(error_message)
+            return error_message
+
+        # Wait before checking again
+        await asyncio.sleep(1)
+
+
+async def invoke_express_state_machine_impl(
+    state_machine_name: str, state_machine_arn: str, parameters: dict, ctx: Context
+) -> str:
+    """Execute an Express state machine using StartSyncExecution."""
+    await ctx.info(f'Starting synchronous execution of Express state machine {state_machine_name}')
+
+    # Start synchronous execution
+    response = sfn_client.start_sync_execution(
+        stateMachineArn=state_machine_arn,
+        input=json.dumps(parameters),
+    )
+
+    # Check execution status
+    status = response['status']
+    await ctx.info(f'Express execution completed with status: {status}')
+
+    if status == 'SUCCEEDED':
+        output = response['output']
+        return format_state_machine_response(state_machine_name, output.encode())
+    else:
+        error_message = (
+            f'Express state machine {state_machine_name} execution failed with status: {status}'
+        )
+        if 'error' in response:
+            error_message += f', error: {response["error"]}'
+        if 'cause' in response:
+            error_message += f', cause: {response["cause"]}'
+        await ctx.error(error_message)
+        return error_message
+
+
+def get_schema_from_registry(schema_arn: str) -> Optional[dict]:
+    """Fetch schema from EventBridge Schema Registry.
+
+    Args:
+        schema_arn: ARN of the schema to fetch
+
+    Returns:
+        Schema content if successful, None if failed
+    """
+    try:
+        # Parse registry name and schema name from ARN
+        # ARN format: arn:aws:schemas:region:account:schema/registry-name/schema-name
+        arn_parts = schema_arn.split(':')
+        if len(arn_parts) < 6:
+            logger.error(f'Invalid schema ARN format: {schema_arn}')
+            return None
+
+        registry_schema = arn_parts[5].split('/')
+        if len(registry_schema) != 3:
+            logger.error(f'Invalid schema path in ARN: {arn_parts[5]}')
+            return None
+
+        registry_name = registry_schema[1]
+        schema_name = registry_schema[2]
+
+        # Get the latest schema version
+        response = schemas_client.describe_schema(
+            RegistryName=registry_name,
+            SchemaName=schema_name,
+        )
+
+        # Return the raw schema content
+        return response['Content']
+
+    except Exception as e:
+        logger.error(f'Error fetching schema from registry: {e}')
+        return None
+
+
+def create_state_machine_tool(
+    state_machine_name: str,
+    state_machine_arn: str,
+    state_machine_type: str,
+    description: str,
+    schema_arn: Optional[str] = None,
+):
+    """Create a tool function for a Step Functions state machine.
+
+    Args:
+        state_machine_name: Name of the Step Functions state machine
+        state_machine_arn: ARN of the Step Functions state machine
+        state_machine_type: Type of the state machine (STANDARD or EXPRESS)
+        description: Base description for the tool
+        schema_arn: Optional ARN of the input schema in the Schema Registry
+    """
+    # Create a meaningful tool name
+    tool_name = sanitize_tool_name(state_machine_name)
+
+    # Define the inner function
+    async def state_machine_function(parameters: dict, ctx: Context) -> str:
+        """Tool for invoking a specific AWS Step Functions state machine with parameters."""
+        # Use the appropriate implementation based on state machine type
+        if state_machine_type == 'EXPRESS':
+            return await invoke_express_state_machine_impl(
+                state_machine_name, state_machine_arn, parameters, ctx
+            )
+        else:  # STANDARD
+            return await invoke_standard_state_machine_impl(
+                state_machine_name, state_machine_arn, parameters, ctx
+            )
+
+    # Set the function's documentation
+    if schema_arn:
+        schema = get_schema_from_registry(schema_arn)
+        if schema:
+            #  We add the schema to the description because mcp.tool does not expose overriding the tool schema.
+            description_with_schema = f'{description}\n\nInput Schema:\n{schema}'
+            state_machine_function.__doc__ = description_with_schema
+            logger.info(
+                f'Added schema from registry to description for state machine {state_machine_name}'
+            )
+        else:
+            state_machine_function.__doc__ = description
+    else:
+        state_machine_function.__doc__ = description
+
+    logger.info(f'Registering tool {tool_name} with description: {description}')
+    # Apply the decorator manually with the specific name
+    decorated_function = mcp.tool(name=tool_name)(state_machine_function)
+
+    return decorated_function
+
+
+def get_schema_arn_from_state_machine_arn(state_machine_arn: str) -> Optional[str]:
+    """Get schema ARN from state machine tags if configured.
+
+    Args:
+        state_machine_arn: ARN of the Step Functions state machine
+
+    Returns:
+        Schema ARN if found and configured, None otherwise
+    """
+    if not STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY:
+        logger.info(
+            'No schema tag environment variable provided (STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY ).'
+        )
+        return None
+
+    try:
+        tags_response = sfn_client.list_tags_for_resource(resourceArn=state_machine_arn)
+        tags = {tag['key']: tag['value'] for tag in tags_response.get('tags', [])}
+        if STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY in tags:
+            return tags[STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY]
+        else:
+            logger.info(
+                f'No schema arn provided for state machine {state_machine_arn} via tag {STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY}'
+            )
+    except Exception as e:
+        logger.warning(f'Error checking tags for state machine {state_machine_arn}: {e}')
+
+    return None
+
+
+def filter_state_machines_by_tag(state_machines, tag_key, tag_value):
+    """Filter Step Functions state machines by a specific tag key-value pair.
+
+    Args:
+        state_machines: List of Step Functions state machine objects
+        tag_key: Tag key to filter by
+        tag_value: Tag value to filter by
+
+    Returns:
+        List of Step Functions state machines that have the specified tag key-value pair
+    """
+    logger.info(f'Filtering state machines by tag key-value pair: {tag_key}={tag_value}')
+    tagged_state_machines = []
+
+    for state_machine in state_machines:
+        try:
+            # Get tags for the state machine
+            tags_response = sfn_client.list_tags_for_resource(
+                resourceArn=state_machine['stateMachineArn']
+            )
+            tags = {tag['key']: tag['value'] for tag in tags_response.get('tags', [])}
+
+            # Check if the state machine has the specified tag key-value pair
+            if tag_key in tags and tags[tag_key] == tag_value:
+                tagged_state_machines.append(state_machine)
+        except Exception as e:
+            logger.warning(f'Error getting tags for state machine {state_machine["name"]}: {e}')
+
+    logger.info(
+        f'{len(tagged_state_machines)} Step Functions state machines found with tag {tag_key}={tag_value}.'
+    )
+    return tagged_state_machines
+
+
+def register_state_machines():
+    """Register Step Functions state machines as individual tools."""
+    try:
+        logger.info('Registering Step Functions state machines as individual tools...')
+        state_machines = sfn_client.list_state_machines()
+
+        # Get all state machines
+        all_state_machines = state_machines['stateMachines']
+        logger.info(f'Total Step Functions state machines found: {len(all_state_machines)}')
+
+        # First filter by state machine name if prefix or list is set
+        if STATE_MACHINE_PREFIX or STATE_MACHINE_LIST:
+            valid_state_machines = [
+                sm for sm in all_state_machines if validate_state_machine_name(sm['name'])
+            ]
+            logger.info(
+                f'{len(valid_state_machines)} Step Functions state machines found after name filtering.'
+            )
+        else:
+            valid_state_machines = all_state_machines
+            logger.info(
+                'No name filtering applied (both STATE_MACHINE_PREFIX and STATE_MACHINE_LIST are empty).'
+            )
+
+        # Then filter by tag if both STATE_MACHINE_TAG_KEY and STATE_MACHINE_TAG_VALUE are set and non-empty
+        if STATE_MACHINE_TAG_KEY and STATE_MACHINE_TAG_VALUE:
+            tagged_state_machines = filter_state_machines_by_tag(
+                valid_state_machines, STATE_MACHINE_TAG_KEY, STATE_MACHINE_TAG_VALUE
+            )
+            valid_state_machines = tagged_state_machines
+        elif STATE_MACHINE_TAG_KEY or STATE_MACHINE_TAG_VALUE:
+            logger.warning(
+                'Both STATE_MACHINE_TAG_KEY and STATE_MACHINE_TAG_VALUE must be set to filter by tag.'
+            )
+            valid_state_machines = []
+
+        for state_machine in valid_state_machines:
+            state_machine_name = state_machine['name']
+            state_machine_arn = state_machine['stateMachineArn']
+
+            # Get state machine description from describe_state_machine
+            try:
+                state_machine_details = sfn_client.describe_state_machine(
+                    stateMachineArn=state_machine_arn
+                )
+                description = state_machine_details.get(
+                    'description', f'AWS Step Functions state machine: {state_machine_name}'
+                )
+                # Parse definition and get Comment if present
+                definition = json.loads(state_machine_details.get('definition', '{}'))
+                if 'Comment' in definition:
+                    description = f'{description}\n\nWorkflow Description: {definition["Comment"]}'
+            except Exception as e:
+                logger.warning(
+                    f'Error getting details for state machine {state_machine_name}: {e}'
+                )
+                description = f'AWS Step Functions state machine: {state_machine_name}'
+
+            schema_arn = get_schema_arn_from_state_machine_arn(state_machine_arn)
+            create_state_machine_tool(
+                state_machine_name,
+                state_machine_arn,
+                state_machine['type'],
+                description,
+                schema_arn,
+            )
+
+        logger.info('Step Functions state machines registered successfully as individual tools.')
+
+    except Exception as e:
+        logger.error(f'Error registering Step Functions state machines as tools: {e}')
+
+
+def main():
+    """Run the MCP server."""
+    register_state_machines()
+    mcp.run()
+
+
+if __name__ == '__main__':
+    main()

awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: awslabs.stepfunctions-tool-mcp-server
+Version: 0.1.4
+Summary: An AWS Labs Model Context Protocol (MCP) server for AWS Step Functions
+Project-URL: Homepage, https://awslabs.github.io/mcp/
+Project-URL: Documentation, https://awslabs.github.io/mcp/servers/stepfunctions-tool-mcp-server/
+Project-URL: Source, https://github.com/awslabs/mcp.git
+Project-URL: Bug Tracker, https://github.com/awslabs/mcp/issues
+Project-URL: Changelog, https://github.com/awslabs/mcp/blob/main/src/stepfunctions-tool-mcp-server/CHANGELOG.md
+Author: Amazon Web Services
+Author-email: AWSLabs MCP <203918161+awslabs-mcp@users.noreply.github.com>
+License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: boto3>=1.37.27
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: pydantic>=2.10.6
+Description-Content-Type: text/markdown
+
+# AWS Step Functions Tool MCP Server
+
+A Model Context Protocol (MCP) server for AWS Step Functions to select and run state machines as MCP tools without code changes.
+
+## Features
+
+This MCP server acts as a **bridge** between MCP clients and AWS Step Functions state machines, allowing generative AI models to access and run state machines as tools. This enables seamless integration with existing Step Function workflows without requiring any modifications to their definitions. Through this bridge, AI models can execute and manage complex, multi-step business processes that coordinate operations across multiple AWS services.
+
+The server supports both Standard and Express workflows, adapting to different execution needs. Standard workflows excel at long-running processes where status tracking is essential, while Express workflows handle high-volume, short-duration tasks with synchronous execution. This flexibility ensures optimal handling of various workflow patterns and requirements.
+
+To ensure data quality and provide clear documentation, the server integrates with EventBridge Schema Registry for input validation. It combines schema information with state machine definitions to generate comprehensive tool documentation, helping AI models understand both the purpose and technical requirements of each workflow.
+
+From a security perspective, the server implements IAM-based authentication and authorization, creating a clear separation of duties. While models can invoke state machines through the MCP server, they don't have direct access to other AWS services. Instead, the state machines themselves handle AWS service interactions using their own IAM roles, maintaining robust security boundaries while enabling powerful workflow capabilities.
+
+```mermaid
+graph LR
+    A[Model] <--> B[MCP Client]
+    B <--> C["MCP2StepFunctions<br>(MCP Server)"]
+    C <--> D[State Machine]
+    D <--> E[Other AWS Services]
+    D <--> F[Internet]
+    D <--> G[VPC]
+
+    style A fill:#f9f,stroke:#333,stroke-width:2px
+    style B fill:#bbf,stroke:#333,stroke-width:2px
+    style C fill:#bfb,stroke:#333,stroke-width:4px
+    style D fill:#fbb,stroke:#333,stroke-width:2px
+    style E fill:#fbf,stroke:#333,stroke-width:2px
+    style F fill:#dff,stroke:#333,stroke-width:2px
+    style G fill:#ffd,stroke:#333,stroke-width:2px
+```
+
+## Prerequisites
+
+1. Install `uv` from [Astral](https://docs.astral.sh/uv/getting-started/installation/) or the [GitHub README](https://github.com/astral-sh/uv#installation)
+2. Install Python using `uv python install 3.10`
+
+## Installation
+
+Here are some ways you can work with MCP across AWS, and we'll be adding support to more products including Amazon Q Developer CLI soon: (e.g. for Amazon Q Developer CLI MCP, `~/.aws/amazonq/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "awslabs.stepfunctions-tool-mcp-server": {
+      "command": "uvx",
+      "args": ["awslabs.stepfunctions-tool-mcp-server@latest"],
+      "env": {
+        "AWS_PROFILE": "your-aws-profile",
+        "AWS_REGION": "us-east-1",
+        "STATE_MACHINE_PREFIX": "your-state-machine-prefix",
+        "STATE_MACHINE_LIST": "your-first-state-machine, your-second-state-machine",
+        "STATE_MACHINE_TAG_KEY": "your-tag-key",
+        "STATE_MACHINE_TAG_VALUE": "your-tag-value",
+        "STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY": "your-state-machine-tag-for-input-schema"
+      }
+    }
+  }
+}
+```
+
+or docker after a successful `docker build -t awslabs/stepfunctions-tool-mcp-server .`:
+
+```file
+# fictitious `.env` file with AWS temporary credentials
+AWS_ACCESS_KEY_ID=ASIAIOSFODNN7EXAMPLE
+AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+AWS_SESSION_TOKEN=AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
+```
+
+```json
+  {
+    "mcpServers": {
+      "awslabs.stepfunctions-tool-mcp-server": {
+        "command": "docker",
+        "args": [
+          "run",
+          "--rm",
+          "--interactive",
+          "--env",
+          "AWS_REGION=us-east-1",
+          "--env",
+          "STATE_MACHINE_PREFIX=your-state-machine-prefix",
+          "--env",
+          "STATE_MACHINE_LIST=your-first-state-machine,your-second-state-machine",
+          "--env",
+          "STATE_MACHINE_TAG_KEY=your-tag-key",
+          "--env",
+          "STATE_MACHINE_TAG_VALUE=your-tag-value",
+          "--env",
+          "STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY=your-state-machine-tag-for-input-schema",
+          "--env-file",
+          "/full/path/to/file/above/.env",
+          "awslabs/stepfunctions-tool-mcp-server:latest"
+        ],
+        "env": {},
+        "disabled": false,
+        "autoApprove": []
+      }
+    }
+  }
+```
+
+NOTE: Your credentials will need to be kept refreshed from your host
+
+The `AWS_PROFILE` and the `AWS_REGION` are optional, their default values are `default` and `us-east-1`.
+
+You can specify `STATE_MACHINE_PREFIX`, `STATE_MACHINE_LIST`, or both. If both are empty, all state machines pass the name check.
+After the name check, if both `STATE_MACHINE_TAG_KEY` and `STATE_MACHINE_TAG_VALUE` are set, state machines are further filtered by tag (with key=value).
+If only one of `STATE_MACHINE_TAG_KEY` and `STATE_MACHINE_TAG_VALUE`, then no state machine is selected and a warning is displayed.
+
+## Tool Documentation
+
+The MCP server builds comprehensive tool documentation by combining multiple sources of information to help AI models understand and use state machines effectively.
+
+1. **State Machine Description**: The state machine's description field provides the base tool description. For example:
+   ```plaintext
+   Retrieve customer status on the CRM system based on { 'customerId' } or { 'customerEmail' }
+   ```
+
+2. **Workflow Description**: The Comment field from the state machine definition adds workflow context. For example:
+   ```json
+   {
+     "Comment": "This workflow first looks up a customer ID from email, then retrieves their info",
+     "StartAt": "GetCustomerId",
+     "States": { ... }
+   }
+   ```
+
+3. **Input Schema**: The server integrates with EventBridge Schema Registry to provide formal JSON Schema documentation for state machine inputs. To enable schema support:
+   - Create your schema in EventBridge Schema Registry
+   - Tag your state machine with the schema ARN:
+     ```plaintext
+     Key: STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY (configurable)
+     Value: arn:aws:schemas:region:account:schema/registry-name/schema-name
+     ```
+   - Configure the MCP server:
+     ```json
+     {
+       "env": {
+         "STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY": "your-schema-arn-tag-key"
+       }
+     }
+     ```
+
+The server combines these sources into a unified documentation format:
+```plaintext
+[State Machine Description]
+
+Workflow Description: [Comment from state machine definition]
+
+Input Schema:
+[JSON Schema from EventBridge Schema Registry]
+```
+
+This comprehensive documentation helps AI models understand both the purpose and technical requirements of each state machine, with formal schema support ensuring correct input formatting.
+
+## Best practices
+
+- Use the `STATE_MACHINE_LIST` to specify the state machines that are available as MCP tools.
+- Use the `STATE_MACHINE_PREFIX` to specify the prefix of the state machines that are available as MCP tools.
+- Use the `STATE_MACHINE_TAG_KEY` and `STATE_MACHINE_TAG_VALUE` to specify the tag key and value of the state machines that are available as MCP tools.
+- AWS Step Functions `Description` property: the description of the state machine is used as MCP tool description, so it should be very detailed to help the model understand when and how to use the state machine
+- Add workflow documentation using the `Comment` field in state machine definitions:
+  - Describe the workflow's purpose and steps
+  - Explain any important logic or conditions
+  - Document expected inputs and outputs
+- Use EventBridge Schema Registry to provide formal input definition:
+  - Create JSON Schema definitions for your state machine inputs
+  - Tag state machines with their schema ARNs
+  - Configure `STATE_MACHINE_INPUT_SCHEMA_ARN_TAG_KEY` in the MCP server
+
+## Security Considerations
+
+When using this MCP server, you should consider:
+
+- Only state machines that are in the provided list or with a name starting with the prefix are imported as MCP tools.
+- The MCP server needs permissions to invoke the state machines.
+- Each state machine has its own permissions to optionally access other AWS resources.

awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+awslabs/__init__.py,sha256=4zfFn3N0BkvQmMTAIvV_QAbKp6GWzrwaUN17YeRoChM,115
+awslabs/stepfunctions_tool_mcp_server/__init__.py,sha256=n0IrKZR35oICjSeI7vz7nq78OleFf8Rvo09My7d7SJY,67
+awslabs/stepfunctions_tool_mcp_server/server.py,sha256=B0yqqtbRS-sKEFaGEUKtTLQ_c2zrCvVDfC5Ry1wc_f8,15474
+awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/METADATA,sha256=tvSFFB0f8U23p7W9tbNlt4kq553TOozKuHkIOiaCMOA,9698
+awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/entry_points.txt,sha256=PVQOhNJ_2mgqvdXcqv2KS8Wa2-vZkjatVw0upZga7RU,108
+awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/licenses/NOTICE,sha256=9GfleTZWBLGtrNSl42TlT_fT7wPBajAx1OQdlIaXUkY,105
+awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/RECORD,,

awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+awslabs.stepfunctions-tool-mcp-server = awslabs.stepfunctions_tool_mcp_server.server:main

awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/licenses/LICENSE

@@ -0,0 +1,175 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.

awslabs_stepfunctions_tool_mcp_server-0.1.4.dist-info/licenses/NOTICE

@@ -0,0 +1,2 @@
+awslabs.stepfunctions-tool-mcp-server
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.