v0.0.17

Author: azdolinski

CHANGELOG.md

@@ -5,31 +5,42 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/),
 and this project adheres to [SimpleTool](https://github.com/nchekwa/simpletool-python/tree/master).
 
-# [0.0.16] - 2025-01-11 Milestone Alpha2
+## [0.0.17] - 2025-01-13 Milestone Alpha2
 
-## Fixed
+### Added
+- add `name` and `description` validation Field rules in `SimpleToolResponseModel`
+- add str to `ResourceConent`-*uri* field to match rfc3986 uris
+
+### Changed
+- `ImageContent` - rename *data* -> *image*
+- `FileContent` - rename *data* -> *file*
+- `ErrorContent` - rename *message* -> *error*
+
+## [0.0.16] - 2025-01-11 Milestone Alpha2
+
+### Fixed
 - incorrect `SimpleToolResponseModel` Pydantic model configuration + from_attributes allow easy serialize/deserialize
 
-# [0.0.15] - 2025-01-09 Milestone Alpha2
+## [0.0.15] - 2025-01-09 Milestone Alpha2
 
-## Fixed
+### Fixed
 - incorrect github action workflow for `setup.py` version
 
-# [0.0.14] - 2025-01-09 Milestone Alpha2
+## [0.0.14] - 2025-01-09 Milestone Alpha2
 
-## Added
+### Added
 - SimpleToolResponseModel
 - add correct handle __repr__ for SimpleTool child classes
 - add get_version for `setup.py` to automate version update
 - auto add annotation version in `__init__.py`
 
-# [0.0.13] - 2025-01-08 Milestone Alpha2
+## [0.0.13] - 2025-01-08 Milestone Alpha2
 
-## Fixed
+### Fixed
 - Updated test import from `BoolContents` to `BoolContent` to match type definition
 
 
-# [0.0.12] - 2025-01-08 Milestone Alpha2
+## [0.0.12] - 2025-01-08 Milestone Alpha2
 
 ### Added
 - added `input_model` will be mandatory - as mapping SimpleInputModel to SimpleTool

requirements.txt

@@ -1 +1,2 @@
-pydantic>=2.10.4
+pydantic>=2.10.4
+rfc3986

setup.py

@@ -9,7 +9,8 @@ def get_version():
         with open('CHANGELOG.md', 'r', encoding='utf-8') as f:
             for line in f:
                 line = line.strip()
-                match = re.search(r'# \[(\d+\.\d+\.\d+)\]', line)
+                # Modified pattern to match both # [...] and ## [...]
+                match = re.search(r'^#{1,2}\s*\[(\d+\.\d+\.\d+)\]', line)
                 if match:
                     version = match.group(1)
 
@@ -40,6 +41,7 @@ def get_version():
         print("CHANGELOG.md not found!")
         return '0.0.0'
 
+
 def read_version_from_init():
     """Read version from __init__.py as a fallback"""
     try:
@@ -55,25 +57,27 @@ def read_version_from_init():
         print(f"Error reading version from __init__.py: {e}")
     return '0.0.0'
 
+
 def write_version_to_metadata(version):
     """Write version to PKG-INFO metadata file"""
     try:
         with open('simpletool.egg-info/PKG-INFO', 'r') as f:
             content = f.read()
-        
+
         # Replace or add Version
         if 'Version:' in content:
             content = re.sub(r'Version:.*', f'Version: {version}', content)
         else:
             content += f'\nVersion: {version}\n'
-        
+
         with open('simpletool.egg-info/PKG-INFO', 'w') as f:
             f.write(content)
-        
+
         print(f"Updated PKG-INFO with version: {version}")
     except Exception as e:
         print(f"Error writing version to metadata: {e}")
 
+
 # First try to get version from CHANGELOG.md
 version = get_version()
 
@@ -92,7 +96,7 @@ def write_version_to_metadata(version):
       author_email='[email protected]',
       license='MIT',
       packages=['simpletool'],
-      install_requires=['pydantic>=2.0.0', 'typing-extensions', 'pydantic>=2.10.4'],
+      install_requires=['pydantic>=2.10.4', 'typing-extensions'],
       long_description=open('README.md').read(),
       long_description_content_type='text/markdown',
       package_data={

simpletool/__init__.py

@@ -12,7 +12,7 @@
 from functools import wraps
 from abc import ABC
 from typing import List, Dict, Any, Union, Type, Literal, Sequence, Tuple, get_args
-from typing import Optional, TypeVar, AnyStr, Callable, Awaitable, Coroutine, ClassVar   # noqa: F401, F403
+from typing import Optional, TypeVar, AnyStr, Callable, Awaitable, Coroutine, ClassVar, TypeAlias   # noqa: F401, F403
 from pydantic import BaseModel, Field
 from pydantic.fields import FieldInfo
 from .types import Content, TextContent, ImageContent, FileContent, ResourceContent, BoolContent, ErrorContent
@@ -50,7 +50,7 @@ async def wrapper(*args, **kwargs):
             except asyncio.TimeoutError:
                 return [ErrorContent(
                     code=408,  # Request Timeout
-                    message=f"Tool execution timed out after {seconds} seconds",
+                    error=f"Tool execution timed out after {seconds} seconds",
                     data={"timeout": seconds}
                 )]
         return wrapper
@@ -238,7 +238,7 @@ async def run(self, arguments: Dict[str, Any]) -> Sequence[Union[Content, TextCo
         except ValidationError as e:
             return [ErrorContent(
                 code=400,  # Bad Request
-                message=f"Input validation error: {str(e)}",
+                error=f"Input validation error: {str(e)}",
                 data={"validation_error": str(e)}
             )]
 
@@ -254,7 +254,7 @@ async def run(self, arguments: Dict[str, Any]) -> Sequence[Union[Content, TextCo
             except asyncio.TimeoutError:
                 return [ErrorContent(
                     code=408,  # Request Timeout
-                    message=f"Tool execution timed out after {self._timeout} seconds",
+                    error=f"Tool execution timed out after {self._timeout} seconds",
                     data={"timeout": self._timeout}
                 )]
         else:
@@ -338,7 +338,7 @@ def info(self) -> str:
 
     @property
     def to_dict(self) -> Dict[str, Any]:
-        """Return a dictionary representation of the tool."""
+        """Convert content to a dictionary representation"""
         sorted_input_schema = self._sort_input_schema(self.input_schema)
         return {
             "name": self.name,

simpletool/models.py

@@ -40,8 +40,17 @@ class SimpleToolResponseModel(BaseModel):
         description (str): A description of the tool's functionality.
         input_schema (Optional[dict]): The input schema for the tool, if available.
     """
-    name: str = Field(..., description="Name of the tool")
-    description: str = Field(..., description="Description of the tool's functionality")
+    name: str = Field(
+        ...,
+        description="Name of the tool",
+        pattern="^[a-zA-Z0-9_-]+$",
+        max_length=64
+    )
+    description: str = Field(
+        ...,
+        description="Description of the tool's functionality",
+        max_length=1024
+    )
     input_schema: Optional[dict] = Field(None, description="Input schema for the tool, if available")
 
     class Config:

simpletool/types.py

@@ -1,9 +1,10 @@
 """ Type definitions for the simpletool package."""
-from typing import Literal, Any, Optional
+from typing import Literal, Any, Optional, Union
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 from pydantic.networks import AnyUrl
 import base64
 
+
 # -------------------------------------------------------------------------------------------------
 # --- CONTENT CLASSES -----------------------------------------------------------------------------
 # -------------------------------------------------------------------------------------------------
@@ -16,12 +17,16 @@ class Content(BaseModel):
 
     @model_validator(mode='before')
     @classmethod
-    def _convert_camel_to_snake_names(cls, data):
-        if isinstance(data, dict) and 'mimeType' in data:
-            data['mime_type'] = data.pop('mimeType')
-        if isinstance(data, dict) and 'fileName' in data:
-            data['file_name'] = data.pop('fileName')
-        return data
+    def convert_field_names(cls, data: dict) -> dict:
+        if not isinstance(data, dict):
+            return data
+
+        field_mappings = {
+            'mimeType': 'mime_type',
+            'fileName': 'file_name'
+        }
+
+        return {field_mappings.get(k, k): v for k, v in data.items()}
 
 
 class TextContent(Content):
@@ -41,66 +46,66 @@ def validate_or_convert(cls, data):
 class ImageContent(Content):
     """Image content for a message."""
     type: Literal["image"] = "image"  # type: ignore
-    data: str
+    image: str
     mime_type: str | None = None
     description: Optional[str] | None = None
 
     @model_validator(mode='before')
     @classmethod
-    def validate_or_convert(cls, data):
+    def validate_or_convert(cls, image):
         # If a string is passed directly, assume it's base64 data
-        if isinstance(data, str):
+        if isinstance(image, str):
             # Validate base64 encoding
             try:
-                base64.b64decode(data, validate=True)
-                return {"data": data}
+                base64.b64decode(image, validate=True)
+                return {"image": image}
             except Exception as e:
-                raise ValueError("Data must be a valid base64 encoded string") from e
-        return data
+                raise ValueError("Image must be a valid base64 encoded string") from e
+        return image
 
-    @field_validator('data')
+    @field_validator('image')
     @classmethod
     def validate_base64(cls, value):
         try:
             base64.b64decode(value, validate=True)
             return value
         except Exception as e:
-            raise ValueError("Data must be a valid base64 encoded string") from e
+            raise ValueError("Image must be a valid base64 encoded string") from e
 
 
 class FileContent(Content):
     type: Literal["file"] = "file"    # type: ignore
-    data: str
+    file: str
     mime_type: str | None = None
     file_name: Optional[str] | None = None
     description: Optional[str] | None = None
 
     @model_validator(mode='before')
     @classmethod
-    def validate_or_convert(cls, data):
+    def validate_or_convert(cls, file):
         # If a string is passed directly, assume it's base64 data
-        if isinstance(data, str):
+        if isinstance(file, str):
             # Validate base64 encoding
             try:
-                base64.b64decode(data, validate=True)
-                return {"data": data}
+                base64.b64decode(file, validate=True)
+                return {"file": file}
             except Exception as e:
-                raise ValueError("Data must be a valid base64 encoded string") from e
-        return data
+                raise ValueError("File must be a valid base64 encoded string") from e
+        return file
 
-    @field_validator('data')
+    @field_validator('file')
     @classmethod
     def validate_base64(cls, value):
         try:
             base64.b64decode(value, validate=True)
             return value
         except Exception as e:
-            raise ValueError("Data must be a valid base64 encoded string") from e
+            raise ValueError("File must be a valid base64 encoded string") from e
 
 
 class ResourceContent(Content):
     type: Literal["resource"] = "resource"  # type: ignore
-    uri: AnyUrl
+    uri: Union[str, AnyUrl]
     name: str
     description: Optional[str] | None = None
     mime_type: str | None = None
@@ -113,12 +118,19 @@ def validate_or_convert(cls, data):
             return {"uri": data, "name": str(data)}
         return data
 
+    @field_validator('uri')
+    @classmethod
+    def validate_uri(cls, v: str) -> str:
+        """Ensure URI is accessible and returns valid status"""
+        # Add URI validation logic here
+        return v
+
 
 class ErrorContent(Content):
     """Error information for JSON-RPC error responses."""
     type: Literal["error"] = "error"    # type: ignore
     code: int = Field(description="A number that indicates the error type that occurred.")
-    message: str = Field(description="A short description of the error. The message SHOULD be limited to a concise single sentence.")
+    error: str = Field(description="A short description of the error. The message SHOULD be limited to a concise single sentence.")
     data: Any | None = Field(default=None, description="Additional information about the error.")
     model_config = ConfigDict(extra="allow")
 

tests/test_models.py

@@ -55,6 +55,20 @@ def test_simple_input_model_camel_case_conversion():
     assert model.camel_case_field == "another test value"
 
 
+def test_simple_input_model_without_input_schema():
+    """Test conversion when inputSchema is not present."""
+    data = {"someField": "test value"}
+    result = SimpleInputModel._convert_camel_to_snake_names(data)
+    assert result == {"someField": "test value"}
+    assert "input_schema" not in result
+
+def test_simple_input_model_with_input_schema():
+    """Test conversion when inputSchema is present."""
+    data = {"inputSchema": {"type": "object"}}
+    result = SimpleInputModel._convert_camel_to_snake_names(data)
+    assert "inputSchema" not in result
+    assert result["input_schema"] == {"type": "object"}
+
 def test_simple_tool_model():
     """Test SimpleToolModel initialization."""
     tool_model = SimpleToolModel(

tests/test_simpletool.py

@@ -93,7 +93,7 @@ async def fast_tool():
     assert len(result) == 1
     assert isinstance(result[0], ErrorContent)
     assert result[0].code == 408
-    assert "timed out" in result[0].message
+    assert "timed out" in result[0].error
 
     # Test non-timeout
     result = asyncio.run(fast_tool())
@@ -232,7 +232,7 @@ async def run(self, arguments: Dict[str, Any]) -> Sequence[Union[TextContent, Er
         if not arguments.get('optional_field'):
             return [ErrorContent(
                 code=400, 
-                message="Optional field is required", 
+                error="Optional field is required", 
                 data={"input": arguments}
             )]
         return [TextContent(type="text", text=str(arguments['optional_field']))]