vellum-ai 0.12.3__py3-none-any.whl → 0.12.5__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.12.3",
+            "X-Fern-SDK-Version": "0.12.5",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/resources/workflows/client.py

@@ -27,7 +27,11 @@ class WorkflowsClient:
         self,
         id: str,
         *,
+        exclude_code: typing.Optional[bool] = None,
         format: typing.Optional[WorkflowsPullRequestFormat] = None,
+        include_json: typing.Optional[bool] = None,
+        include_sandbox: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> typing.Iterator[bytes]:
         """
@@ -38,8 +42,16 @@ class WorkflowsClient:
         id : str
             The ID of the Workflow to pull from
 
+        exclude_code : typing.Optional[bool]
+
         format : typing.Optional[WorkflowsPullRequestFormat]
 
+        include_json : typing.Optional[bool]
+
+        include_sandbox : typing.Optional[bool]
+
+        strict : typing.Optional[bool]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -53,7 +65,11 @@ class WorkflowsClient:
             base_url=self._client_wrapper.get_environment().default,
             method="GET",
             params={
+                "exclude_code": exclude_code,
                 "format": format,
+                "include_json": include_json,
+                "include_sandbox": include_sandbox,
+                "strict": strict,
             },
             request_options=request_options,
         ) as _response:
@@ -164,7 +180,11 @@ class AsyncWorkflowsClient:
         self,
         id: str,
         *,
+        exclude_code: typing.Optional[bool] = None,
         format: typing.Optional[WorkflowsPullRequestFormat] = None,
+        include_json: typing.Optional[bool] = None,
+        include_sandbox: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> typing.AsyncIterator[bytes]:
         """
@@ -175,8 +195,16 @@ class AsyncWorkflowsClient:
         id : str
             The ID of the Workflow to pull from
 
+        exclude_code : typing.Optional[bool]
+
         format : typing.Optional[WorkflowsPullRequestFormat]
 
+        include_json : typing.Optional[bool]
+
+        include_sandbox : typing.Optional[bool]
+
+        strict : typing.Optional[bool]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -190,7 +218,11 @@ class AsyncWorkflowsClient:
             base_url=self._client_wrapper.get_environment().default,
             method="GET",
             params={
+                "exclude_code": exclude_code,
                 "format": format,
+                "include_json": include_json,
+                "include_sandbox": include_sandbox,
+                "strict": strict,
             },
             request_options=request_options,
         ) as _response:

vellum/client/types/chat_message_prompt_block.py

@@ -16,9 +16,9 @@ class ChatMessagePromptBlock(UniversalBaseModel):
     A block that represents a chat message in a prompt template.
     """
 
+    block_type: typing.Literal["CHAT_MESSAGE"] = "CHAT_MESSAGE"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["CHAT_MESSAGE"] = "CHAT_MESSAGE"
     chat_role: ChatMessageRole
     chat_source: typing.Optional[str] = None
     chat_message_unterminated: typing.Optional[bool] = None

vellum/client/types/function_definition.py

@@ -4,22 +4,41 @@ from ..core.pydantic_utilities import UniversalBaseModel
 import typing
 from .prompt_block_state import PromptBlockState
 from .ephemeral_prompt_cache_config import EphemeralPromptCacheConfig
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
 
 
 class FunctionDefinition(UniversalBaseModel):
     """
-    A block that represents a function definition in a prompt template.
+    The definition of a Function (aka "Tool Call") that a Prompt/Model has access to.
     """
 
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    name: typing.Optional[str] = None
-    description: typing.Optional[str] = None
-    parameters: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
-    forced: typing.Optional[bool] = None
-    strict: typing.Optional[bool] = None
+    name: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The name identifying the function.
+    """
+
+    description: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    A description to help guide the model when to invoke this function.
+    """
+
+    parameters: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
+    """
+    An OpenAPI specification of parameters that are supported by this function.
+    """
+
+    forced: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Set this option to true to force the model to return a function call of this function.
+    """
+
+    strict: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Set this option to use strict schema decoding when available.
+    """
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/jinja_prompt_block.py

@@ -13,9 +13,9 @@ class JinjaPromptBlock(UniversalBaseModel):
     A block of Jinja template code that is used to generate a prompt
     """
 
+    block_type: typing.Literal["JINJA"] = "JINJA"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["JINJA"] = "JINJA"
     template: str
 
     if IS_PYDANTIC_V2:

vellum/client/types/plain_text_prompt_block.py

@@ -13,9 +13,9 @@ class PlainTextPromptBlock(UniversalBaseModel):
     A block that holds a plain text string value.
     """
 
+    block_type: typing.Literal["PLAIN_TEXT"] = "PLAIN_TEXT"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["PLAIN_TEXT"] = "PLAIN_TEXT"
     text: str
 
     if IS_PYDANTIC_V2:

vellum/client/types/rich_text_prompt_block.py

@@ -14,9 +14,9 @@ class RichTextPromptBlock(UniversalBaseModel):
     A block that includes a combination of plain text and variable blocks.
     """
 
+    block_type: typing.Literal["RICH_TEXT"] = "RICH_TEXT"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["RICH_TEXT"] = "RICH_TEXT"
     blocks: typing.List[RichTextChildBlock]
 
     if IS_PYDANTIC_V2:

vellum/client/types/variable_prompt_block.py

@@ -13,9 +13,9 @@ class VariablePromptBlock(UniversalBaseModel):
     A block that represents a variable in a prompt template.
     """
 
+    block_type: typing.Literal["VARIABLE"] = "VARIABLE"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["VARIABLE"] = "VARIABLE"
     input_variable: str
 
     if IS_PYDANTIC_V2:

vellum/plugins/vellum_mypy.py

@@ -172,41 +172,39 @@ class VellumMypyPlugin(Plugin):
 
     def _dynamic_output_node_class_hook(self, ctx: ClassDefContext, attribute_name: str) -> None:
         """
-        We use this hook to properly annotate the Outputs class for Templating Node using the resolved type
-        of the TemplatingNode's class _OutputType generic.
+        We use this hook to properly annotate the Outputs class for Templating Node and
+        Code Execution Node using the resolved type
+        of the TemplatingNode's and CodeExecutionNode's class _OutputType generic.
         """
-
-        templating_node_info = ctx.cls.info
-        templating_node_bases = ctx.cls.info.bases
-        if not templating_node_bases:
+        node_info = ctx.cls.info
+        node_bases = ctx.cls.info.bases
+        if not node_bases:
             return
-        if not isinstance(templating_node_bases[0], Instance):
+        if not isinstance(node_bases[0], Instance):
             return
 
-        base_templating_args = templating_node_bases[0].args
-        base_templating_node = templating_node_bases[0].type
-        if not _is_subclass(base_templating_node, "vellum.workflows.nodes.core.templating_node.node.TemplatingNode"):
-            return
+        base_args = node_bases[0].args
+        base_node = node_bases[0].type
 
-        if len(base_templating_args) != 2:
+        if len(base_args) != 2:
             return
 
-        base_templating_node_resolved_type = base_templating_args[1]
-        if isinstance(base_templating_node_resolved_type, AnyType):
-            base_templating_node_resolved_type = ctx.api.named_type("builtins.str")
+        base_node_resolved_type = base_args[1]
+        if isinstance(base_node_resolved_type, AnyType):
+            base_node_resolved_type = ctx.api.named_type("builtins.str")
 
-        base_templating_node_outputs = base_templating_node.names.get("Outputs")
-        if not base_templating_node_outputs:
+        base_node_outputs = base_node.names.get("Outputs")
+        if not base_node_outputs:
             return
 
-        current_templating_node_outputs = templating_node_info.names.get("Outputs")
-        if not current_templating_node_outputs:
-            templating_node_info.names["Outputs"] = base_templating_node_outputs.copy()
-            new_outputs_sym = templating_node_info.names["Outputs"].node
+        current_node_outputs = node_info.names.get("Outputs")
+        if not current_node_outputs:
+            node_info.names["Outputs"] = base_node_outputs.copy()
+            new_outputs_sym = node_info.names["Outputs"].node
             if isinstance(new_outputs_sym, TypeInfo):
                 result_sym = new_outputs_sym.names[attribute_name].node
                 if isinstance(result_sym, Var):
-                    result_sym.type = base_templating_node_resolved_type
+                    result_sym.type = base_node_resolved_type
 
     def _base_node_class_hook(self, ctx: ClassDefContext) -> None:
         """
@@ -233,7 +231,6 @@ class VellumMypyPlugin(Plugin):
             type_ = sym.node.type
             if not type_:
                 continue
-
             sym.node.type = self._get_resolvable_type(
                 lambda fullname, types: ctx.api.named_type(fullname, types), type_
             )

vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -1,3 +1,4 @@
+import json
 from uuid import uuid4
 from typing import ClassVar, Generic, Iterator, List, Optional, Tuple, cast
 
@@ -18,6 +19,7 @@ from vellum.client import RequestOptions
 from vellum.workflows.constants import OMIT
 from vellum.workflows.context import get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.events.types import default_serializer
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
 from vellum.workflows.nodes.displayable.bases.inline_prompt_node.constants import DEFAULT_PROMPT_PARAMETERS
@@ -108,19 +110,30 @@ class BaseInlinePromptNode(BasePromptNode, Generic[StateType]):
                         value=cast(List[ChatMessage], input_value),
                     )
                 )
-            elif isinstance(input_value, dict):
-                # Note: We may want to fail early here if we know that input_value is not
-                #   JSON serializable.
+            else:
+                try:
+                    input_value = default_serializer(input_value)
+                except json.JSONDecodeError as e:
+                    raise NodeException(
+                        message=f"Failed to serialize input '{input_name}' of type '{input_value.__class__}': {e}",
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                    )
+
+                input_variables.append(
+                    VellumVariable(
+                        # TODO: Determine whether or not we actually need an id here and if we do,
+                        #   figure out how to maintain stable id references.
+                        #   https://app.shortcut.com/vellum/story/4080
+                        id=str(uuid4()),
+                        key=input_name,
+                        type="JSON",
+                    )
+                )
                 input_values.append(
                     PromptRequestJsonInput(
                         key=input_name,
                         value=input_value,
                     )
                 )
-            else:
-                raise NodeException(
-                    message=f"Unrecognized input type for input '{input_name}': {input_value.__class__}",
-                    code=WorkflowErrorCode.INVALID_INPUTS,
-                )
 
         return input_variables, input_values

vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+from uuid import uuid4
+from typing import Any, Iterator, List
+
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types.execute_prompt_event import ExecutePromptEvent
+from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
+from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
+from vellum.client.types.prompt_output import PromptOutput
+from vellum.client.types.prompt_request_json_input import PromptRequestJsonInput
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+
+
+def test_inline_prompt_node__json_inputs(vellum_adhoc_prompt_client):
+    # GIVEN a prompt node with various inputs
+    @dataclass
+    class MyDataClass:
+        hello: str
+
+    class MyPydantic(UniversalBaseModel):
+        example: str
+
+    class MyNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = []
+        prompt_inputs = {
+            "a_dict": {"foo": "bar"},
+            "a_list": [1, 2, 3],
+            "a_dataclass": MyDataClass(hello="world"),
+            "a_pydantic": MyPydantic(example="example"),
+        }
+
+    # AND a known response from invoking an inline prompt
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value="Test"),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    list(MyNode().run())
+
+    # THEN the prompt is executed with the correct inputs
+    mock_api = vellum_adhoc_prompt_client.adhoc_execute_prompt_stream
+    assert mock_api.call_count == 1
+    assert mock_api.call_args.kwargs["input_values"] == [
+        PromptRequestJsonInput(key="a_dict", type="JSON", value={"foo": "bar"}),
+        PromptRequestJsonInput(key="a_list", type="JSON", value=[1, 2, 3]),
+        PromptRequestJsonInput(key="a_dataclass", type="JSON", value={"hello": "world"}),
+        PromptRequestJsonInput(key="a_pydantic", type="JSON", value={"example": "example"}),
+    ]
+    assert len(mock_api.call_args.kwargs["input_variables"]) == 4

vellum/workflows/sandbox.py

@@ -0,0 +1,51 @@
+from typing import Generic, Sequence, Type
+
+import dotenv
+
+from vellum.workflows.events.workflow import WorkflowEventStream
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.logging import load_logger
+from vellum.workflows.types.generics import WorkflowType
+from vellum.workflows.workflows.event_filters import root_workflow_event_filter
+
+
+class SandboxRunner(Generic[WorkflowType]):
+    def __init__(self, workflow: Type[WorkflowType], inputs: Sequence[BaseInputs]):
+        if not inputs:
+            raise ValueError("Inputs are required to have at least one defined inputs")
+
+        self._workflow = workflow
+        self._inputs = inputs
+
+        dotenv.load_dotenv()
+        self._logger = load_logger()
+
+    def run(self, index: int = 0):
+        if index < 0:
+            self._logger.warning("Index is less than 0, running first input")
+            index = 0
+        elif index >= len(self._inputs):
+            self._logger.warning("Index is greater than the number of provided inputs, running last input")
+            index = len(self._inputs) - 1
+
+        selected_inputs = self._inputs[index]
+
+        workflow = self._workflow()
+        events = workflow.stream(
+            inputs=selected_inputs,
+            event_filter=root_workflow_event_filter,
+        )
+
+        self._process_events(events)
+
+    def _process_events(self, events: WorkflowEventStream):
+        for event in events:
+            if event.name == "workflow.execution.fulfilled":
+                self._logger.info("Workflow fulfilled!")
+                for output_reference, value in event.outputs:
+                    self._logger.info("----------------------------------")
+                    self._logger.info(f"{output_reference.name}: {value}")
+            elif event.name == "node.execution.initiated":
+                self._logger.info(f"Just started Node: {event.node_definition.__name__}")
+            elif event.name == "node.execution.fulfilled":
+                self._logger.info(f"Just finished Node: {event.node_definition.__name__}")

vellum/workflows/tests/test_sandbox.py

@@ -0,0 +1,62 @@
+import pytest
+from typing import List
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.sandbox import SandboxRunner
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+
+
+@pytest.fixture
+def mock_logger(mocker):
+    return mocker.patch("vellum.workflows.sandbox.load_logger")
+
+
+@pytest.mark.parametrize(
+    ["run_kwargs", "expected_last_log"],
+    [
+        ({}, "final_results: first"),
+        ({"index": 1}, "final_results: second"),
+        ({"index": -4}, "final_results: first"),
+        ({"index": 100}, "final_results: second"),
+    ],
+    ids=["default", "specific", "negative", "out_of_bounds"],
+)
+def test_sandbox_runner__happy_path(mock_logger, run_kwargs, expected_last_log):
+    # GIVEN we capture the logs to stdout
+    logs = []
+    mock_logger.return_value.info.side_effect = lambda msg: logs.append(msg)
+
+    # AND an example workflow
+    class Inputs(BaseInputs):
+        foo: str
+
+    class StartNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            bar = Inputs.foo
+
+    class Workflow(BaseWorkflow[Inputs, BaseState]):
+        graph = StartNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_results = StartNode.Outputs.bar
+
+    # AND a dataset for this workflow
+    inputs: List[Inputs] = [
+        Inputs(foo="first"),
+        Inputs(foo="second"),
+    ]
+
+    # WHEN we run the sandbox
+    runner = SandboxRunner(workflow=Workflow, inputs=inputs)
+    runner.run(**run_kwargs)
+
+    # THEN we see the logs
+    assert logs == [
+        "Just started Node: StartNode",
+        "Just finished Node: StartNode",
+        "Workflow fulfilled!",
+        "----------------------------------",
+        expected_last_log,
+    ]

vellum/workflows/types/core.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from typing import (  # type: ignore[attr-defined]
+    Any,
     Dict,
     List,
     Union,
@@ -8,22 +9,6 @@ from typing import (  # type: ignore[attr-defined]
     _UnionGenericAlias,
 )
 
-from vellum import (
-    ChatMessage,
-    FunctionCall,
-    FunctionCallRequest,
-    SearchResult,
-    SearchResultRequest,
-    VellumAudio,
-    VellumAudioRequest,
-    VellumError,
-    VellumErrorRequest,
-    VellumImage,
-    VellumImageRequest,
-    VellumValue,
-    VellumValueRequest,
-)
-
 JsonArray = List["Json"]
 JsonObject = Dict[str, "Json"]
 Json = Union[None, bool, int, float, str, JsonArray, JsonObject]
@@ -42,42 +27,7 @@ class VellumSecret:
         self.name = name
 
 
-VellumValuePrimitive = Union[
-    # String inputs
-    str,
-    # Chat history inputs
-    List[ChatMessage],
-    List[ChatMessage],
-    # Search results inputs
-    List[SearchResultRequest],
-    List[SearchResult],
-    # JSON inputs
-    Json,
-    # Number inputs
-    float,
-    # Function Call Inputs
-    FunctionCall,
-    FunctionCallRequest,
-    # Error Inputs
-    VellumError,
-    VellumErrorRequest,
-    # Array Inputs
-    List[VellumValueRequest],
-    List[VellumValue],
-    # Image Inputs
-    VellumImage,
-    VellumImageRequest,
-    # Audio Inputs
-    VellumAudio,
-    VellumAudioRequest,
-    # Vellum Secrets
-    VellumSecret,
-]
-
-EntityInputsInterface = Dict[
-    str,
-    VellumValuePrimitive,
-]
+EntityInputsInterface = Dict[str, Any]
 
 
 class MergeBehavior(Enum):

vellum/workflows/utils/functions.py

@@ -1,6 +1,9 @@
 import dataclasses
 import inspect
-from typing import Any, Callable, Union, get_args, get_origin
+from typing import Any, Callable, Optional, Union, get_args, get_origin
+
+from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
 
 from vellum.client.types.function_definition import FunctionDefinition
 
@@ -16,7 +19,10 @@ type_map = {
 }
 
 
-def _compile_annotation(annotation: Any, defs: dict[str, Any]) -> dict:
+def _compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
+    if annotation is None:
+        return {"type": "null"}
+
     if get_origin(annotation) is Union:
         return {"anyOf": [_compile_annotation(a, defs) for a in get_args(annotation)]}
 
@@ -37,13 +43,44 @@ def _compile_annotation(annotation: Any, defs: dict[str, Any]) -> dict:
                 if field.default is dataclasses.MISSING:
                     required.append(field.name)
                 else:
-                    properties[field.name]["default"] = field.default
+                    properties[field.name]["default"] = _compile_default_value(field.default)
+            defs[annotation.__name__] = {"type": "object", "properties": properties, "required": required}
+        return {"$ref": f"#/$defs/{annotation.__name__}"}
+
+    if issubclass(annotation, BaseModel):
+        if annotation.__name__ not in defs:
+            properties = {}
+            required = []
+            for field_name, field in annotation.model_fields.items():
+                # Mypy is incorrect here, the `annotation` attribute is defined on `FieldInfo`
+                field_annotation = field.annotation  # type: ignore[attr-defined]
+                properties[field_name] = _compile_annotation(field_annotation, defs)
+                if field.default is PydanticUndefined:
+                    required.append(field_name)
+                else:
+                    properties[field_name]["default"] = _compile_default_value(field.default)
             defs[annotation.__name__] = {"type": "object", "properties": properties, "required": required}
+
         return {"$ref": f"#/$defs/{annotation.__name__}"}
 
     return {"type": type_map[annotation]}
 
 
+def _compile_default_value(default: Any) -> Any:
+    if dataclasses.is_dataclass(default):
+        return {
+            field.name: _compile_default_value(getattr(default, field.name)) for field in dataclasses.fields(default)
+        }
+
+    if isinstance(default, BaseModel):
+        return {
+            field_name: _compile_default_value(getattr(default, field_name))
+            for field_name in default.model_fields.keys()
+        }
+
+    return default
+
+
 def compile_function_definition(function: Callable) -> FunctionDefinition:
     """
     Converts a Python function into our Vellum-native FunctionDefinition type.
@@ -62,7 +99,7 @@ def compile_function_definition(function: Callable) -> FunctionDefinition:
         if param.default is inspect.Parameter.empty:
             required.append(param.name)
         else:
-            properties[param.name]["default"] = param.default
+            properties[param.name]["default"] = _compile_default_value(param.default)
 
     parameters = {"type": "object", "properties": properties, "required": required}
     if defs: