Implement inline default format for tool parameters - Replace separate parameter_defaults with inline format - Use generic TypedDict with NotRequired for better type safety - Remove manual default value injection, rely on msgspec auto-handling - Update all tests to use inline format instead of separate mapping

Author: baonudesifeizhai

src/lmstudio/json_api.py

@@ -1090,14 +1090,23 @@ def __init__(
         super().__init__(model_key, params, on_load_progress)
 
 
+# Add new type definitions for inline parameter format
+from typing import TypeVar
+from typing_extensions import NotRequired
+
+T = TypeVar('T')
+
+class ToolParamDefDict(TypedDict, Generic[T]):
+    type: type[T]
+    default: NotRequired[T]
+
 class ToolFunctionDefDict(TypedDict, total=False):
     """SDK input format to specify an LLM tool call and its implementation (as a dict)."""
 
     name: str
     description: str
-    parameters: Mapping[str, Any]
+    parameters: Mapping[str, type[Any] | ToolParamDefDict[Any]]
     implementation: Callable[..., Any]
-    parameter_defaults: Mapping[str, Any]
 
 
 @dataclass(kw_only=True, frozen=True, slots=True)
@@ -1106,18 +1115,29 @@ class ToolFunctionDef:
 
     name: str
     description: str
-    parameters: Mapping[str, Any]
+    parameters: Mapping[str, type[Any] | ToolParamDefDict[Any]]
     implementation: Callable[..., Any]
-    parameter_defaults: Mapping[str, Any] = field(default_factory=dict)
+
+    def _extract_type_and_default(self, param_name: str, param_value: type[Any] | ToolParamDefDict[Any]) -> tuple[type[Any], Any | None]:
+        """Extract type and default value from parameter definition."""
+        if isinstance(param_value, dict) and "type" in param_value:
+            # Inline format: {"type": type, "default": value}
+            param_type = param_value["type"]
+            default_value = param_value.get("default")
+            return param_type, default_value
+        else:
+            # Simple format: just the type
+            return param_value, None
 
     def _to_llm_tool_def(self) -> tuple[type[Struct], LlmTool]:
         params_struct_name = f"{self.name.capitalize()}Parameters"
 
         # Build fields list with defaults
         fields: list[tuple[str, Any] | tuple[str, Any, Any]] = []
-        for param_name, param_type in self.parameters.items():
-            if param_name in self.parameter_defaults:
-                default_value = self.parameter_defaults[param_name]
+        for param_name, param_value in self.parameters.items():
+            param_type, default_value = self._extract_type_and_default(param_name, param_value)
+            
+            if default_value is not None:
                 fields.append((param_name, param_type, default_value))
             else:
                 fields.append((param_name, param_type))
@@ -1174,13 +1194,17 @@ def from_callable(
         # Tool definitions only annotate the input parameters, not the return type
         parameters.pop("return", None)
 
-        # Extract default values from function signature
-        parameter_defaults: dict[str, Any] = {}
+        # Extract default values from function signature and convert to inline format
         try:
             sig = inspect.signature(f)
             for param_name, param in sig.parameters.items():
                 if param.default is not inspect.Parameter.empty:
-                    parameter_defaults[param_name] = param.default
+                    # Convert to inline format: {"type": type, "default": value}
+                    original_type = parameters[param_name]
+                    parameters[param_name] = {
+                        "type": original_type,
+                        "default": param.default
+                    }
         except Exception as exc:
             # If we can't extract defaults, continue without them
             pass
@@ -1189,8 +1213,7 @@ def from_callable(
             name=name, 
             description=description, 
             parameters=parameters, 
-            implementation=f,
-            parameter_defaults=parameter_defaults
+            implementation=f
         )
 
 
@@ -1632,18 +1655,7 @@ def parse_tools(
             else:
                 # Handle dictionary-based tool definition
                 tool_dict = cast(ToolFunctionDefDict, tool)
-                name = cast(str, tool_dict["name"])
-                description = cast(str, tool_dict["description"])
-                parameters = cast(Mapping[str, Any], tool_dict["parameters"])
-                implementation = cast(Callable[..., Any], tool_dict["implementation"])
-                parameter_defaults = cast(Mapping[str, Any], tool_dict.get("parameter_defaults", {}))
-                tool_def = ToolFunctionDef(
-                    name=name,
-                    description=description,
-                    parameters=parameters,
-                    implementation=implementation,
-                    parameter_defaults=parameter_defaults
-                )
+                tool_def = ToolFunctionDef(**tool_dict)
             if tool_def.name in client_tool_map:
                 raise LMStudioValueError(
                     f"Duplicate tool names are not permitted ({tool_def.name!r} repeated)"

src/lmstudio/schemas.py

@@ -66,27 +66,8 @@ def _to_json_schema(cls: type, *, omit: Sequence[str] = ()) -> DictSchema:
             named_schema.pop(field, None)
         json_schema.update(named_schema)
 
-    # Add default values to properties if they exist in the msgspec Struct
-    if hasattr(cls, "__struct_fields__") and hasattr(cls, "__struct_defaults__"):
-        properties = json_schema.get("properties", {})
-        if properties:
-            # Get ordered field names and default values
-            field_names = cls.__struct_fields__
-            default_values = cls.__struct_defaults__
-            
-            # Map default values to field names by position
-            # Only fields with defaults will have entries in default_values
-            default_count = len(default_values)
-            field_count = len(field_names)
-            
-            # For kw_only=True structs, default values correspond to the last N fields
-            # where N is the number of default values
-            for i, field_name in enumerate(field_names):
-                if field_name in properties:
-                    # Calculate the index into default_values
-                    default_index = i - (field_count - default_count)
-                    if 0 <= default_index < default_count:
-                        properties[field_name]["default"] = default_values[default_index]
+    # msgspec automatically handles default values in the generated JSON schema
+    # when they are properly defined in the Struct fields
 
     return json_schema
 

tests/test_default_values.py

@@ -2,6 +2,7 @@
 
 import pytest
 from typing import Any
+from msgspec import defstruct
 
 from src.lmstudio.json_api import ToolFunctionDef, ToolFunctionDefDict
 from src.lmstudio.schemas import _to_json_schema
@@ -29,113 +30,154 @@ def calculate(expression: str, precision: int = 2) -> str:
         precision: Number of decimal places (default: 2)
     
     Returns:
-        The calculated result
+        The calculated result as a string
     """
     return f"Result: {eval(expression):.{precision}f}"
 
 
 class TestDefaultValues:
-    """Test default parameter value functionality."""
-    
+    """Test cases for default parameter values in tool definitions."""
+
     def test_extract_defaults_from_callable(self):
-        """Test extracting default values from function signature."""
+        """Test extracting default values from a callable function."""
         tool_def = ToolFunctionDef.from_callable(greet)
 
         assert tool_def.name == "greet"
-        assert tool_def.parameter_defaults == {
-            "greeting": "Hello",
-            "punctuation": "!"
-        }
-        assert "name" not in tool_def.parameter_defaults
+        # Check that defaults are converted to inline format
+        assert tool_def.parameters["greeting"] == {"type": str, "default": "Hello"}
+        assert tool_def.parameters["punctuation"] == {"type": str, "default": "!"}
+        assert tool_def.parameters["name"] == str  # No default, just type
 
-    def test_manual_defaults(self):
-        """Test manually specifying default values."""
+    def test_manual_inline_defaults(self):
+        """Test manually specifying default values in inline format."""
         tool_def = ToolFunctionDef(
             name="calculate",
             description="Calculate a mathematical expression",
-            parameters={"expression": str, "precision": int},
-            implementation=calculate,
-            parameter_defaults={"precision": 2}
+            parameters={
+                "expression": str,
+                "precision": {"type": int, "default": 2}
+            },
+            implementation=calculate
         )
 
-        assert tool_def.parameter_defaults == {"precision": 2}
-        assert "expression" not in tool_def.parameter_defaults
+        # Check that the inline format is preserved
+        assert tool_def.parameters["precision"] == {"type": int, "default": 2}
+        assert tool_def.parameters["expression"] == str  # No default, just type
 
     def test_json_schema_with_defaults(self):
-        """Test that JSON Schema includes default values."""
+        """Test that JSON schema includes default values."""
         tool_def = ToolFunctionDef.from_callable(greet)
         params_struct, _ = tool_def._to_llm_tool_def()
-        json_schema = _to_json_schema(params_struct)
-        
-        properties = json_schema["properties"]
-        
-        # name should not have a default (required parameter)
-        assert "name" in properties
-        assert "default" not in properties["name"]
 
-        # greeting should have default "Hello"
-        assert "greeting" in properties
-        assert properties["greeting"]["default"] == "Hello"
-        
-        # punctuation should have default "!"
-        assert "punctuation" in properties
-        assert properties["punctuation"]["default"] == "!"
+        json_schema = _to_json_schema(params_struct)
 
-        # Only name should be required
-        assert json_schema["required"] == ["name"]
+        # Check that default values are included in the schema
+        assert json_schema["properties"]["greeting"]["default"] == "Hello"
+        assert json_schema["properties"]["punctuation"]["default"] == "!"
+        assert "default" not in json_schema["properties"]["name"]
 
     def test_dict_based_definition(self):
-        """Test dictionary-based tool definition with defaults."""
+        """Test dictionary-based tool definition with inline defaults."""
         dict_tool: ToolFunctionDefDict = {
             "name": "format_text",
             "description": "Format text with specified style",
-            "parameters": {"text": str, "style": str, "uppercase": bool},
-            "implementation": lambda text, style="normal", uppercase=False: text.upper() if uppercase else text,
-            "parameter_defaults": {"style": "normal", "uppercase": False}
+            "parameters": {
+                "text": str,
+                "style": {"type": str, "default": "normal"},
+                "uppercase": {"type": bool, "default": False}
+            },
+            "implementation": lambda text, style="normal", uppercase=False: text.upper() if uppercase else text
         }
 
         # This should work without errors
         tool_def = ToolFunctionDef(**dict_tool)
-        assert tool_def.parameter_defaults == {"style": "normal", "uppercase": False}
+        assert tool_def.parameters["style"] == {"type": str, "default": "normal"}
+        assert tool_def.parameters["uppercase"] == {"type": bool, "default": False}
+        assert tool_def.parameters["text"] == str  # No default, just type
 
     def test_no_defaults(self):
         """Test function with no default values."""
         def no_defaults(a: int, b: str) -> str:
             """Function with no default parameters."""
-            return f"{a}{b}"
+            return f"{a}: {b}"
 
         tool_def = ToolFunctionDef.from_callable(no_defaults)
-        assert tool_def.parameter_defaults == {}
+        # All parameters should be simple types without defaults
+        assert tool_def.parameters["a"] == int
+        assert tool_def.parameters["b"] == str
 
         params_struct, _ = tool_def._to_llm_tool_def()
         json_schema = _to_json_schema(params_struct)
 
-        # All parameters should be required
-        assert json_schema["required"] == ["a", "b"]
-        
-        # No properties should have defaults
-        for prop in json_schema["properties"].values():
-            assert "default" not in prop
+        # No default values should be present
+        assert "default" not in json_schema["properties"]["a"]
+        assert "default" not in json_schema["properties"]["b"]
 
     def test_mixed_defaults(self):
-        """Test function with some parameters having defaults."""
+        """Test function with some parameters having defaults and others not."""
         def mixed_defaults(required: str, optional1: int = 42, optional2: bool = True) -> str:
             """Function with mixed required and optional parameters."""
-            return f"{required}{optional1}{optional2}"
+            return f"{required}: {optional1}, {optional2}"
 
         tool_def = ToolFunctionDef.from_callable(mixed_defaults)
-        assert tool_def.parameter_defaults == {
-            "optional1": 42,
-            "optional2": True
-        }
+        # Check inline format for parameters with defaults
+        assert tool_def.parameters["optional1"] == {"type": int, "default": 42}
+        assert tool_def.parameters["optional2"] == {"type": bool, "default": True}
+        assert tool_def.parameters["required"] == str  # No default, just type
 
         params_struct, _ = tool_def._to_llm_tool_def()
         json_schema = _to_json_schema(params_struct)
 
-        # Only required should be in required list
-        assert json_schema["required"] == ["required"]
-        
-        # Check defaults
+        # Check that default values are correctly included in schema
         assert json_schema["properties"]["optional1"]["default"] == 42
         assert json_schema["properties"]["optional2"]["default"] is True
         assert "default" not in json_schema["properties"]["required"]
+    
+    def test_extract_type_and_default_method(self):
+        """Test the _extract_type_and_default helper method."""
+        tool_def = ToolFunctionDef(
+            name="test",
+            description="Test tool",
+            parameters={
+                "simple": str,
+                "with_default": {"type": int, "default": 42},
+                "complex_default": {"type": list, "default": [1, 2, 3]}
+            },
+            implementation=lambda x, y, z: None
+        )
+        
+        # Test simple type
+        param_type, default = tool_def._extract_type_and_default("simple", str)
+        assert param_type == str
+        assert default is None
+        
+        # Test inline format with default
+        param_type, default = tool_def._extract_type_and_default("with_default", {"type": int, "default": 42})
+        assert param_type == int
+        assert default == 42
+        
+        # Test complex default
+        param_type, default = tool_def._extract_type_and_default("complex_default", {"type": list, "default": [1, 2, 3]})
+        assert param_type == list
+        assert default == [1, 2, 3]
+
+    def test_msgspec_auto_defaults(self):
+        """msgspec automatically reflects default values in the JSON schema."""
+        TestStruct = defstruct(
+            "TestStruct",
+            [
+                ("name", str),
+                ("age", int, 18),
+                ("active", bool, True),
+            ],
+            kw_only=True,
+        )
+
+        schema = _to_json_schema(TestStruct)
+        properties = schema.get("properties", {})
+        required = schema.get("required", [])
+
+        assert "name" in properties and "default" not in properties["name"]
+        assert properties["age"].get("default") == 18
+        assert properties["active"].get("default") is True
+        assert "name" in required and "age" not in required and "active" not in required