Python: Fix non-string KernelArguments being converted to strings in prompt template function calls (#13292)

### Motivation and Context

Fixes #13199 - Non-string kernel arguments are now preserved when passed
to functions in prompt templates. Adds unit tests.

<!-- Thank you for your contribution to the semantic-kernel repo!
Please help reviewers and future users, providing the following
information:
  1. Why is this change required?
  2. What problem does it solve?
  3. What scenario does it contribute to?
  4. If it fixes an open issue, please link to the issue here.
-->

### Contribution Checklist

<!-- Before submitting this PR, please make sure: -->

- [X] The code builds clean without any errors or warnings
- [X] The PR follows the [SK Contribution
Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md)
and the [pre-submission formatting
script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts)
raises no violations
- [X] All unit tests pass, and I have added new tests where possible
- [X] I didn't break anyone 😄

Author: moonbox3

python/semantic_kernel/template_engine/blocks/code_block.py

@@ -149,7 +149,22 @@ def _enrich_function_arguments(
             )
         for index, token in enumerate(self.tokens[1:], start=1):
             logger.debug(f"Parsing variable/value: `{self.tokens[1].content}`")
-            rendered_value = token.render(kernel, arguments)  # type: ignore
+
+            # For VarBlock, get the raw value to preserve the original type
+            # For other blocks (ValBlock, NamedArgBlock), render to string as usual
+            from semantic_kernel.template_engine.blocks.var_block import VarBlock
+
+            if isinstance(token, VarBlock):
+                rendered_value = token.get_value(arguments)
+            elif isinstance(token, NamedArgBlock):
+                # NamedArgBlock may contain a VarBlock, so check for that
+                if token.variable:
+                    rendered_value = token.variable.get_value(arguments)
+                else:
+                    rendered_value = token.render(kernel, arguments)
+            else:
+                rendered_value = token.render(kernel, arguments)  # type: ignore
+
             if not isinstance(token, NamedArgBlock) and index == 1:
                 arguments[function_metadata.parameters[0].name] = rendered_value
                 continue

python/semantic_kernel/template_engine/blocks/var_block.py

@@ -82,3 +82,18 @@ def render(self, _: "Kernel", arguments: Optional["KernelArguments"] = None) ->
             raise VarBlockRenderError(
                 f"Block {self.name} failed to be parsed to a string, type is {type(value)}"
             ) from e
+
+    def get_value(self, arguments: "KernelArguments | None" = None) -> Any:
+        """Get the raw value of the variable from arguments without converting to string.
+
+        This is used when passing arguments to functions to preserve their original types.
+
+        Args:
+            arguments: The KernelArguments to get the value from.
+
+        Returns:
+            The raw value from the arguments, or None if not found.
+        """
+        if arguments is None:
+            return None
+        return arguments.get(self.name, None)

python/tests/unit/template_engine/blocks/test_code_block.py

@@ -483,3 +483,99 @@ def test_edge_cases(case, result):
 def test_no_tokens():
     with raises(CodeBlockTokenError):
         CodeBlock(content="", tokens=[])
+
+
+class TestNonStringArguments:
+    """Test that non-string KernelArguments are preserved when passed to functions in templates."""
+
+    async def test_function_receives_int_type(self, kernel: Kernel):
+        """Test that an integer argument is passed as int, not converted to string."""
+        received_value = None
+        received_type = None
+
+        @kernel_function(name="check_type")
+        def check_type(value: int):
+            nonlocal received_value, received_type
+            received_value = value
+            received_type = type(value)
+            return f"Received {type(value).__name__}: {value}"
+
+        function = KernelFunctionFromMethod(method=check_type, plugin_name="test")
+        kernel.add_plugin(KernelPlugin(name="test", functions=[function]))
+
+        code_block = CodeBlock(content="test.check_type value=$my_int")
+        arguments = KernelArguments(my_int=42)
+
+        await code_block.render_code(kernel, arguments)
+
+        assert received_value == 42
+        assert isinstance(received_value, int), f"Expected int but got {received_type}"
+
+    async def test_function_receives_list_type(self, kernel: Kernel):
+        """Test that a list argument is passed as list, not converted to string."""
+        received_value = None
+        received_type = None
+
+        @kernel_function(name="check_type")
+        def check_type(items: list):
+            nonlocal received_value, received_type
+            received_value = items
+            received_type = type(items)
+            return f"Received {len(items)} items"
+
+        function = KernelFunctionFromMethod(method=check_type, plugin_name="test")
+        kernel.add_plugin(KernelPlugin(name="test", functions=[function]))
+
+        code_block = CodeBlock(content="test.check_type items=$my_list")
+        arguments = KernelArguments(my_list=[1, 2, 3])
+
+        await code_block.render_code(kernel, arguments)
+
+        assert received_value == [1, 2, 3]
+        assert isinstance(received_value, list), f"Expected list but got {received_type}"
+
+    async def test_function_receives_dict_type(self, kernel: Kernel):
+        """Test that a dict argument is passed as dict, not converted to string."""
+        received_value = None
+        received_type = None
+
+        @kernel_function(name="check_type")
+        def check_type(data: dict):
+            nonlocal received_value, received_type
+            received_value = data
+            received_type = type(data)
+            return f"Received dict with keys: {list(data.keys())}"
+
+        function = KernelFunctionFromMethod(method=check_type, plugin_name="test")
+        kernel.add_plugin(KernelPlugin(name="test", functions=[function]))
+
+        code_block = CodeBlock(content="test.check_type data=$my_dict")
+        arguments = KernelArguments(my_dict={"key": "value", "num": 123})
+
+        await code_block.render_code(kernel, arguments)
+
+        assert received_value == {"key": "value", "num": 123}
+        assert isinstance(received_value, dict), f"Expected dict but got {received_type}"
+
+    async def test_named_arg_with_non_string_type(self, kernel: Kernel):
+        """Test that named arguments with non-string types are preserved."""
+        received_count = None
+        received_type = None
+
+        @kernel_function(name="process")
+        def process(text: str, count: int):
+            nonlocal received_count, received_type
+            received_count = count
+            received_type = type(count)
+            return f"{text} x {count}"
+
+        function = KernelFunctionFromMethod(method=process, plugin_name="test")
+        kernel.add_plugin(KernelPlugin(name="test", functions=[function]))
+
+        code_block = CodeBlock(content="test.process 'hello' count=$repetitions")
+        arguments = KernelArguments(repetitions=5)
+
+        await code_block.render_code(kernel, arguments)
+
+        assert received_count == 5
+        assert isinstance(received_count, int), f"Expected int but got {received_type}"