vellum-ai 0.12.3__tar.gz → 0.12.4__tar.gz

{vellum_ai-0.12.3 → vellum_ai-0.12.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.12.3
+Version: 0.12.4
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.12.3 → vellum_ai-0.12.4}/ee/vellum_ee/workflows/display/utils/vellum.py

@@ -9,7 +9,6 @@ from vellum.workflows.references import OutputReference, WorkflowInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
-from vellum.workflows.types.core import VellumValuePrimitive
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -93,7 +92,7 @@ def create_node_input_value_pointer_rule(
     raise ValueError(f"Unsupported descriptor type: {value.__class__.__name__}")
 
 
-def primitive_to_vellum_value(value: VellumValuePrimitive) -> VellumValue:
+def primitive_to_vellum_value(value: Any) -> VellumValue:
     """Converts a python primitive to a VellumVariableValue"""
 
     if isinstance(value, str):

{vellum_ai-0.12.3 → vellum_ai-0.12.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.12.3"
+version = "0.12.4"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.12.3 → vellum_ai-0.12.4}/src/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.4",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.12.3 → vellum_ai-0.12.4}/src/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_ai-0.12.3 → vellum_ai-0.12.4}/src/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_ai-0.12.4/src/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_ai-0.12.4/src/vellum/workflows/types/core.py

@@ -0,0 +1,42 @@
+from enum import Enum
+from typing import (  # type: ignore[attr-defined]
+    Any,
+    Dict,
+    List,
+    Union,
+    _GenericAlias,
+    _SpecialGenericAlias,
+    _UnionGenericAlias,
+)
+
+JsonArray = List["Json"]
+JsonObject = Dict[str, "Json"]
+Json = Union[None, bool, int, float, str, JsonArray, JsonObject]
+
+# Unions and Generics inherit from `_GenericAlias` instead of `type`
+# In future versions of python, we'll see `_UnionGenericAlias`
+UnderGenericAlias = _GenericAlias
+SpecialGenericAlias = _SpecialGenericAlias
+UnionGenericAlias = _UnionGenericAlias
+
+
+class VellumSecret:
+    name: str
+
+    def __init__(self, name: str):
+        self.name = name
+
+
+EntityInputsInterface = Dict[str, Any]
+
+
+class MergeBehavior(Enum):
+    AWAIT_ALL = "AWAIT_ALL"
+    AWAIT_ANY = "AWAIT_ANY"
+    AWAIT_ATTRIBUTES = "AWAIT_ATTRIBUTES"
+
+
+class ConditionType(Enum):
+    IF = "IF"
+    ELIF = "ELIF"
+    ELSE = "ELSE"

vellum_ai-0.12.3/src/vellum/workflows/types/core.py

@@ -1,92 +0,0 @@
-from enum import Enum
-from typing import (  # type: ignore[attr-defined]
-    Dict,
-    List,
-    Union,
-    _GenericAlias,
-    _SpecialGenericAlias,
-    _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]
-
-# Unions and Generics inherit from `_GenericAlias` instead of `type`
-# In future versions of python, we'll see `_UnionGenericAlias`
-UnderGenericAlias = _GenericAlias
-SpecialGenericAlias = _SpecialGenericAlias
-UnionGenericAlias = _UnionGenericAlias
-
-
-class VellumSecret:
-    name: str
-
-    def __init__(self, name: str):
-        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,
-]
-
-
-class MergeBehavior(Enum):
-    AWAIT_ALL = "AWAIT_ALL"
-    AWAIT_ANY = "AWAIT_ANY"
-    AWAIT_ATTRIBUTES = "AWAIT_ATTRIBUTES"
-
-
-class ConditionType(Enum):
-    IF = "IF"
-    ELIF = "ELIF"
-    ELSE = "ELSE"