vellum-ai 0.13.15__py3-none-any.whl → 0.13.18__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.13.15",
+            "X-Fern-SDK-Version": "0.13.18",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/resources/workflows/client.py

@@ -96,7 +96,6 @@ class WorkflowsClient:
         self,
         *,
         exec_config: WorkflowPushExecConfig,
-        label: str,
         workflow_sandbox_id: typing.Optional[str] = OMIT,
         deployment_config: typing.Optional[WorkflowPushDeploymentConfigRequest] = OMIT,
         artifact: typing.Optional[core.File] = OMIT,
@@ -110,8 +109,6 @@ class WorkflowsClient:
         exec_config : WorkflowPushExecConfig
             The execution configuration of the workflow.
 
-        label : str
-
         workflow_sandbox_id : typing.Optional[str]
 
         deployment_config : typing.Optional[WorkflowPushDeploymentConfigRequest]
@@ -140,7 +137,6 @@ class WorkflowsClient:
         )
         client.workflows.push(
             exec_config="exec_config",
-            label="label",
         )
         """
         _response = self._client_wrapper.httpx_client.request(
@@ -149,7 +145,6 @@ class WorkflowsClient:
             method="POST",
             data={
                 "exec_config": exec_config,
-                "label": label,
                 "workflow_sandbox_id": workflow_sandbox_id,
                 "deployment_config": deployment_config,
                 "dry_run": dry_run,
@@ -253,7 +248,6 @@ class AsyncWorkflowsClient:
         self,
         *,
         exec_config: WorkflowPushExecConfig,
-        label: str,
         workflow_sandbox_id: typing.Optional[str] = OMIT,
         deployment_config: typing.Optional[WorkflowPushDeploymentConfigRequest] = OMIT,
         artifact: typing.Optional[core.File] = OMIT,
@@ -267,8 +261,6 @@ class AsyncWorkflowsClient:
         exec_config : WorkflowPushExecConfig
             The execution configuration of the workflow.
 
-        label : str
-
         workflow_sandbox_id : typing.Optional[str]
 
         deployment_config : typing.Optional[WorkflowPushDeploymentConfigRequest]
@@ -302,7 +294,6 @@ class AsyncWorkflowsClient:
         async def main() -> None:
             await client.workflows.push(
                 exec_config="exec_config",
-                label="label",
             )
 
 
@@ -314,7 +305,6 @@ class AsyncWorkflowsClient:
             method="POST",
             data={
                 "exec_config": exec_config,
-                "label": label,
                 "workflow_sandbox_id": workflow_sandbox_id,
                 "deployment_config": deployment_config,
                 "dry_run": dry_run,

vellum/workflows/nodes/core/templating_node/node.py

@@ -1,7 +1,4 @@
-import json
-from typing import Any, Callable, ClassVar, Dict, Generic, Mapping, Tuple, Type, TypeVar, Union, get_args, get_origin
-
-from pydantic import BaseModel
+from typing import Any, Callable, ClassVar, Dict, Generic, Mapping, Tuple, Type, TypeVar, Union, get_args
 
 from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS
 from vellum.utils.templating.exceptions import JinjaTemplateError
@@ -10,7 +7,8 @@ from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.types.core import EntityInputsInterface, Json
+from vellum.workflows.nodes.utils import parse_type_from_str
+from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
 
@@ -79,48 +77,7 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
         else:
             output_type = all_args[1]
 
-        if output_type is str:
-            return rendered_template
-
-        if output_type is float:
-            return float(rendered_template)
-
-        if output_type is int:
-            return int(rendered_template)
-
-        if output_type is bool:
-            return bool(rendered_template)
-
-        if get_origin(output_type) is list:
-            try:
-                data = json.loads(rendered_template)
-            except json.JSONDecodeError:
-                raise ValueError("Invalid JSON Array format for rendered_template")
-
-            if not isinstance(data, list):
-                raise ValueError(f"Expected a list of items for rendered_template, received {data.__class__.__name__}")
-
-            inner_type = get_args(output_type)[0]
-            if issubclass(inner_type, BaseModel):
-                return [inner_type.model_validate(item) for item in data]
-            else:
-                return data
-
-        if output_type is Json:
-            try:
-                return json.loads(rendered_template)
-            except json.JSONDecodeError:
-                raise ValueError("Invalid JSON format for rendered_template")
-
-        if issubclass(output_type, BaseModel):
-            try:
-                data = json.loads(rendered_template)
-            except json.JSONDecodeError:
-                raise ValueError("Invalid JSON format for rendered_template")
-
-            return output_type.model_validate(data)
-
-        raise ValueError(f"Unsupported output type: {output_type}")
+        return parse_type_from_str(rendered_template, output_type)
 
     def run(self) -> Outputs:
         rendered_template = self._render_template()

vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -19,12 +19,13 @@ from vellum import (
     VellumError,
     VellumValue,
 )
+from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.core import RequestOptions
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.nodes.displayable.code_execution_node.utils import read_file_from_path
+from vellum.workflows.nodes.displayable.code_execution_node.utils import read_file_from_path, run_code_inline
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, VellumSecret
 from vellum.workflows.types.generics import StateType
@@ -93,23 +94,31 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
 
     def run(self) -> Outputs:
         input_values = self._compile_code_inputs()
-        expected_output_type = primitive_type_to_vellum_variable_type(self.__class__.get_output_type())
-        code_execution = self._context.vellum_client.execute_code(
-            input_values=input_values,
-            code=self._resolve_code(),
-            runtime=self.runtime,
-            output_type=expected_output_type,
-            packages=self.packages or [],
-            request_options=self.request_options,
-        )
-
-        if code_execution.output.type != expected_output_type:
-            raise NodeException(
-                code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message=f"Expected an output of type '{expected_output_type}', received '{code_execution.output.type}'",
+        output_type = self.__class__.get_output_type()
+        code = self._resolve_code()
+        if not self.packages and self.runtime == "PYTHON_3_11_6":
+            logs, result = run_code_inline(code, input_values, output_type)
+            return self.Outputs(result=result, log=logs)
+        else:
+            expected_output_type = primitive_type_to_vellum_variable_type(output_type)
+
+            code_execution_result = self._context.vellum_client.execute_code(
+                input_values=input_values,
+                code=code,
+                runtime=self.runtime,
+                output_type=expected_output_type,
+                packages=self.packages or [],
+                request_options=self.request_options,
             )
 
-        return self.Outputs(result=code_execution.output.value, log=code_execution.log)
+            if code_execution_result.output.type != expected_output_type:
+                actual_type = code_execution_result.output.type
+                raise NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message=f"Expected an output of type '{expected_output_type}', received '{actual_type}'",
+                )
+
+            return self.Outputs(result=code_execution_result.output.value, log=code_execution_result.log)
 
     def _compile_code_inputs(self) -> List[CodeExecutorInput]:
         # TODO: We may want to consolidate with prompt deployment input compilation
@@ -127,13 +136,10 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
                 )
             elif isinstance(input_value, VellumSecret):
                 compiled_inputs.append(
-                    # TODO: Expose a VellumSecret type from the Vellum SDK
-                    # https://app.shortcut.com/vellum/story/4785
-                    {  # type: ignore[arg-type]
-                        "name": input_name,
-                        "type": "SECRET",
-                        "value": input_value.name,
-                    }
+                    CodeExecutorSecretInput(
+                        name=input_name,
+                        value=input_value.name,
+                    )
                 )
             elif isinstance(input_value, list):
                 if all(isinstance(message, ChatMessage) for message in input_value):

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -2,6 +2,9 @@ import pytest
 import os
 
 from vellum import CodeExecutorResponse, NumberVellumValue, StringInput
+from vellum.client.types.code_execution_package import CodeExecutionPackage
+from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
+from vellum.client.types.function_call import FunctionCall
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
@@ -24,6 +27,12 @@ def test_run_workflow__happy_path(vellum_client):
     class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
         filepath = fixture
         runtime = "PYTHON_3_11_6"
+        packages = [
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ]
 
         code_inputs = {
             "word": Inputs.word,
@@ -59,7 +68,12 @@ def main(word: str) -> int:
 """,
         runtime="PYTHON_3_11_6",
         output_type="NUMBER",
-        packages=[],
+        packages=[
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ],
         request_options=None,
     )
 
@@ -81,6 +95,12 @@ def main(word: str) -> int:
     return len(word)
 """
         runtime = "PYTHON_3_11_6"
+        packages = [
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ]
 
         code_inputs = {
             "word": Inputs.word,
@@ -116,7 +136,12 @@ def main(word: str) -> int:
 """,
         runtime="PYTHON_3_11_6",
         output_type="NUMBER",
-        packages=[],
+        packages=[
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ],
         request_options=None,
     )
 
@@ -141,6 +166,12 @@ def main(word: str) -> int:
     return len(word)
 """
         runtime = "PYTHON_3_11_6"
+        packages = [
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ]
 
         code_inputs = {
             "word": Inputs.word,
@@ -178,6 +209,12 @@ def test_run_workflow__code_and_filepath_not_defined(vellum_client):
 
     class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
         runtime = "PYTHON_3_11_6"
+        packages = [
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ]
 
         code_inputs = {
             "word": Inputs.word,
@@ -215,9 +252,15 @@ def test_run_workflow__vellum_secret(vellum_client):
     class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
         filepath = fixture
         runtime = "PYTHON_3_11_6"
+        packages = [
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ]
 
         code_inputs = {
-            "token": VellumSecretReference("OPENAI_API_KEY"),
+            "word": VellumSecretReference("OPENAI_API_KEY"),
         }
 
     # AND we know what the Code Execution Node will respond with
@@ -237,7 +280,10 @@ def test_run_workflow__vellum_secret(vellum_client):
     # AND we should have invoked the Code with the expected inputs
     vellum_client.execute_code.assert_called_once_with(
         input_values=[
-            {"name": "token", "type": "SECRET", "value": "OPENAI_API_KEY"},
+            CodeExecutorSecretInput(
+                name="word",
+                value="OPENAI_API_KEY",
+            )
         ],
         code="""\
 def main(word: str) -> int:
@@ -246,6 +292,124 @@ def main(word: str) -> int:
 """,
         runtime="PYTHON_3_11_6",
         output_type="NUMBER",
-        packages=[],
+        packages=[
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ],
         request_options=None,
     )
+
+
+def test_run_workflow__run_inline(vellum_client):
+    """Confirm that CodeExecutionNodes run the code inline instead of through Vellum under certain conditions."""
+
+    # GIVEN a node that subclasses CodeExecutionNode
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, int]):
+        code = """\
+def main(word: str) -> int:
+    print(word)  # noqa: T201
+    return len(word)
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "word": "hello",
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should have produced the outputs we expect
+    assert outputs == {"result": 5, "log": "hello\n"}
+
+    # AND we should have not invoked the Code via Vellum
+    vellum_client.execute_code.assert_not_called()
+
+
+def test_run_workflow__run_inline__incorrect_output_type():
+    """Confirm that CodeExecutionNodes raise an error if the output type is incorrect during inline execution."""
+
+    # GIVEN a node that subclasses CodeExecutionNode that returns a string but is defined to return an int
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, int]):
+        code = """\
+def main(word: str) -> int:
+    return word
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "word": "hello",
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN the node should have produced the exception we expected
+    assert exc_info.value.message == "Expected an output of type 'int', but received 'str'"
+
+
+def test_run_workflow__run_inline__valid_dict_to_pydantic():
+    """Confirm that CodeExecutionNodes can convert a dict to a Pydantic model during inline execution."""
+
+    # GIVEN a node that subclasses CodeExecutionNode that returns a dict matching a Pydantic model
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, FunctionCall]):
+        code = """\
+def main(word: str) -> int:
+    return {
+        "name": word,
+        "arguments": {},
+    }
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "word": "hello",
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should have produced the outputs we expect
+    assert outputs == {"result": FunctionCall(name="hello", arguments={}), "log": ""}
+
+
+def test_run_workflow__run_inline__invalid_dict_to_pydantic():
+    """Confirm that CodeExecutionNodes raise an error if the Pydantic validation fails during inline execution."""
+
+    # GIVEN a node that subclasses CodeExecutionNode that returns a dict not matching a Pydantic model
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, FunctionCall]):
+        code = """\
+def main(word: str) -> int:
+    return {
+        "n": word,
+        "a": {},
+    }
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "word": "hello",
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN the node should have produced the exception we expected
+    assert (
+        exc_info.value.message
+        == """\
+2 validation errors for FunctionCall
+arguments
+  Field required [type=missing, input_value={'n': 'hello', 'a': {}}, input_type=dict]
+name
+  Field required [type=missing, input_value={'n': 'hello', 'a': {}}, input_type=dict]\
+"""
+    )

vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -1,5 +1,13 @@
+import io
 import os
-from typing import Union
+import re
+from typing import Any, List, Tuple, Union
+
+from pydantic import BaseModel, ValidationError
+
+from vellum.client.types.code_executor_input import CodeExecutorInput
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 
 
 def read_file_from_path(node_filepath: str, script_filepath: str) -> Union[str, None]:
@@ -10,3 +18,92 @@ def read_file_from_path(node_filepath: str, script_filepath: str) -> Union[str,
         with open(full_filepath) as file:
             return file.read()
     return None
+
+
+class ListWrapper(list):
+    def __getitem__(self, key):
+        item = super().__getitem__(key)
+        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
+            self.__setitem__(key, _clean_for_dict_wrapper(item))
+
+        return super().__getitem__(key)
+
+
+class DictWrapper(dict):
+    """
+    This wraps a dict object to make it behave basically the same as a standard javascript object
+    and enables us to use vellum types here without a shared library since we don't actually
+    typecheck things here.
+    """
+
+    def __getitem__(self, key):
+        return self.__getattr__(key)
+
+    def __getattr__(self, attr):
+        if attr not in self:
+            raise AttributeError(f"Vellum object has no attribute '{attr}'")
+
+        item = super().__getitem__(attr)
+        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
+            self.__setattr__(attr, _clean_for_dict_wrapper(item))
+
+        return super().__getitem__(attr)
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+
+def _clean_for_dict_wrapper(obj):
+    if isinstance(obj, dict):
+        wrapped = DictWrapper(obj)
+        for key in wrapped:
+            wrapped[key] = _clean_for_dict_wrapper(wrapped[key])
+
+        return wrapped
+
+    elif isinstance(obj, list):
+        return ListWrapper(map(lambda item: _clean_for_dict_wrapper(item), obj))
+
+    return obj
+
+
+def run_code_inline(
+    code: str,
+    input_values: List[CodeExecutorInput],
+    output_type: Any,
+) -> Tuple[str, Any]:
+    log_buffer = io.StringIO()
+
+    exec_globals = {
+        "__arg__inputs": {input_value.name: _clean_for_dict_wrapper(input_value.value) for input_value in input_values},
+        "__arg__out": None,
+        "print": lambda *args, **kwargs: log_buffer.write(f"{' '.join(args)}\n"),
+    }
+    run_args = [f"{input_value.name}=__arg__inputs['{input_value.name}']" for input_value in input_values]
+    execution_code = f"""\
+{code}
+
+__arg__out = main({", ".join(run_args)})
+"""
+
+    exec(execution_code, exec_globals)
+
+    logs = log_buffer.getvalue()
+    result = exec_globals["__arg__out"]
+
+    if issubclass(output_type, BaseModel) and not isinstance(result, output_type):
+        try:
+            result = output_type.model_validate(result)
+        except ValidationError as e:
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
+            ) from e
+
+    if not isinstance(result, output_type):
+        raise NodeException(
+            code=WorkflowErrorCode.INVALID_OUTPUTS,
+            message=f"Expected an output of type '{output_type.__name__}', but received '{result.__class__.__name__}'",
+        )
+
+    return logs, result

vellum/workflows/nodes/utils.py

@@ -1,11 +1,15 @@
 from functools import cache
+import json
 import sys
 from types import ModuleType
-from typing import Any, Callable, Optional, Type, TypeVar
+from typing import Any, Callable, Optional, Type, TypeVar, get_args, get_origin
+
+from pydantic import BaseModel
 
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.ports.port import Port
+from vellum.workflows.types.core import Json
 from vellum.workflows.types.generics import NodeType
 
 ADORNMENT_MODULE_NAME = "<adornment>"
@@ -73,3 +77,48 @@ def create_adornment(
         return WrappedNode
 
     return decorator
+
+
+def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
+    if output_type is str:
+        return result_as_str
+
+    if output_type is float:
+        return float(result_as_str)
+
+    if output_type is int:
+        return int(result_as_str)
+
+    if output_type is bool:
+        return bool(result_as_str)
+
+    if get_origin(output_type) is list:
+        try:
+            data = json.loads(result_as_str)
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON Array format for result_as_str")
+
+        if not isinstance(data, list):
+            raise ValueError(f"Expected a list of items for result_as_str, received {data.__class__.__name__}")
+
+        inner_type = get_args(output_type)[0]
+        if issubclass(inner_type, BaseModel):
+            return [inner_type.model_validate(item) for item in data]
+        else:
+            return data
+
+    if output_type is Json:
+        try:
+            return json.loads(result_as_str)
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON format for result_as_str")
+
+    if issubclass(output_type, BaseModel):
+        try:
+            data = json.loads(result_as_str)
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON format for result_as_str")
+
+        return output_type.model_validate(data)
+
+    raise ValueError(f"Unsupported output type: {output_type}")

vellum/workflows/references/external_input.py

@@ -42,6 +42,20 @@ class ExternalInputReference(BaseDescriptor[_InputType], Generic[_InputType]):
 
         raise NodeException(f"Missing required Node Input: {self._name}", code=WorkflowErrorCode.INVALID_INPUTS)
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, type(self)):
+            return False
+
+        # Check equality of the name
+        base_equal = super().__eq__(other)
+        if not base_equal:
+            return False
+
+        return self._inputs_class == other._inputs_class
+
+    def __hash__(self) -> int:
+        return hash((self._name, self._inputs_class))
+
     @classmethod
     def __get_pydantic_core_schema__(
         cls, source_type: Type[Any], handler: GetCoreSchemaHandler

vellum/workflows/state/base.py

@@ -201,6 +201,7 @@ class StateMeta(UniversalBaseModel):
 
     def add_snapshot_callback(self, callback: Callable[[], None]) -> None:
         self.node_outputs = _make_snapshottable(self.node_outputs, callback)
+        self.external_inputs = _make_snapshottable(self.external_inputs, callback)
         self.__snapshot_callback__ = callback
 
     def __setattr__(self, name: str, value: Any) -> None:
@@ -231,7 +232,13 @@ class StateMeta(UniversalBaseModel):
             for descriptor, value in self.node_outputs.items()
         }
 
+        new_external_inputs = {
+            descriptor: value if isinstance(value, Queue) else deepcopy(value, memo)
+            for descriptor, value in self.external_inputs.items()
+        }
+
         memo[id(self.node_outputs)] = new_node_outputs
+        memo[id(self.external_inputs)] = new_external_inputs
         memo[id(self.__snapshot_callback__)] = None
 
         return super().__deepcopy__(memo)