vellum-ai 1.7.0__tar.gz → 1.7.1__tar.gz

{vellum_ai-1.7.0 → vellum_ai-1.7.1}/PKG-INFO

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

{vellum_ai-1.7.0 → vellum_ai-1.7.1}/ee/vellum_ee/assets/node-definitions.json

@@ -699,6 +699,51 @@
         }
       ]
     },
+    {
+      "id": "ee9b5234-247b-49d1-bed4-490312f18838",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "Used to render a Jinja template.\n\n    Useful for lightweight data transformations and complex string templating.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "TemplatingNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "core",
+          "templating_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "005e1cd2-5452-4e1f-be6a-ac9fe3c02b9b",
+        "merge_behavior": "AWAIT_ATTRIBUTES"
+      },
+      "ports": [
+        {
+          "id": "8f4460f0-717b-4972-a6f4-ac164e5e204e",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
     {
       "id": "035842e0-34ed-43af-97de-a706e40912ae",
       "label": "Tool Calling Node",
@@ -1010,10 +1055,5 @@
       ]
     }
   ],
-  "errors": [
-    {
-      "node": "TemplatingNode",
-      "error": "KeyError: TemplatingNode.Outputs.result"
-    }
-  ]
+  "errors": []
 }

{vellum_ai-1.7.0 → vellum_ai-1.7.1}/ee/vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -50,7 +50,7 @@ class BaseTemplatingNodeDisplay(BaseNodeDisplay[_TemplatingNodeType], Generic[_T
         # Misc type ignore is due to `node.Outputs` being generic
         # https://app.shortcut.com/vellum/story/4784
         output_descriptor = node.Outputs.result  # type: ignore [misc]
-        output_display = display_context.global_node_output_displays[output_descriptor]
+        output_display = self.get_node_output_display(output_descriptor)
         inferred_output_type = primitive_type_to_vellum_variable_type(output_descriptor)
 
         return {

{vellum_ai-1.7.0 → vellum_ai-1.7.1}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py

@@ -353,3 +353,33 @@ def test_serialize_node__adornment_order_matches_decorator_order():
     assert len(adornments) == 2
     assert adornments[0]["label"] == "Try Node"
     assert adornments[1]["label"] == "Retry Node"
+
+
+def test_serialize_workflow__retry_node_edges():
+    """
+    Tests that both retry-adorned nodes are correctly serialized in the nodes array.
+    """
+
+    @RetryNode.wrap(max_attempts=3, delay=60)
+    class FirstNode(BaseNode):
+        class Outputs(BaseOutputs):
+            value: str
+
+    @RetryNode.wrap(max_attempts=5, delay=120)
+    class SecondNode(BaseNode):
+        class Outputs(BaseOutputs):
+            result: str
+
+    class MyWorkflow(BaseWorkflow):
+        graph = FirstNode >> SecondNode
+
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    exec_config = cast(Dict[str, Any], workflow_display.serialize())
+
+    assert isinstance(exec_config["workflow_raw_data"], dict)
+    assert isinstance(exec_config["workflow_raw_data"]["nodes"], list)
+
+    nodes = cast(List[Dict[str, Any]], exec_config["workflow_raw_data"]["nodes"])
+
+    generic_nodes = [node for node in nodes if node["type"] == "GENERIC"]
+    assert len(generic_nodes) == 2

{vellum_ai-1.7.0 → vellum_ai-1.7.1}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -208,7 +208,15 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 self.display_context.add_invalid_node(node)
                 continue
 
-            serialized_nodes[node_display.node_id] = serialized_node
+            # Use wrapped node's ID as dict key for adornment wrappers to prevent overwrites
+            wrapped_node = get_wrapped_node(node)
+            if wrapped_node:
+                wrapped_node_display = self.display_context.node_displays[wrapped_node]
+                dict_key = wrapped_node_display.node_id
+            else:
+                dict_key = node_display.node_id
+
+            serialized_nodes[dict_key] = serialized_node
 
         synthetic_output_edges: JsonArray = []
         output_variables: JsonArray = []

{vellum_ai-1.7.0 → vellum_ai-1.7.1}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.7.0"
+version = "1.7.1"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-1.7.0 → vellum_ai-1.7.1}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.7.0",
+            "User-Agent": "vellum-ai/1.7.1",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.7.0",
+            "X-Fern-SDK-Version": "1.7.1",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum_ai-1.7.1/src/vellum/workflows/resolvers/resolver.py

@@ -0,0 +1,80 @@
+import logging
+from uuid import UUID
+from typing import Iterator, Optional, Type, Union
+
+from vellum.workflows.events.workflow import WorkflowEvent
+from vellum.workflows.nodes.utils import cast_to_output_type
+from vellum.workflows.resolvers.base import BaseWorkflowResolver
+from vellum.workflows.resolvers.types import LoadStateResult
+from vellum.workflows.state.base import BaseState
+
+logger = logging.getLogger(__name__)
+
+
+class VellumResolver(BaseWorkflowResolver):
+    def get_latest_execution_events(self) -> Iterator[WorkflowEvent]:
+        return iter([])
+
+    def get_state_snapshot_history(self) -> Iterator[BaseState]:
+        return iter([])
+
+    def _deserialize_state(self, state_data: dict, state_class: Type[BaseState]) -> BaseState:
+        """Deserialize state data with proper type conversion for complex types like List[ChatMessage]."""
+        converted_data = {}
+
+        annotations = getattr(state_class, "__annotations__", {})
+
+        for field_name, field_value in state_data.items():
+            if field_name in annotations:
+                field_type = annotations[field_name]
+                converted_data[field_name] = cast_to_output_type(field_value, field_type)
+            else:
+                converted_data[field_name] = field_value
+
+        return state_class(**converted_data)
+
+    def load_state(self, previous_execution_id: Optional[Union[UUID, str]] = None) -> Optional[LoadStateResult]:
+        if isinstance(previous_execution_id, UUID):
+            previous_execution_id = str(previous_execution_id)
+
+        if previous_execution_id is None:
+            return None
+
+        if not self._context:
+            logger.warning("Cannot load state: No workflow context registered")
+            return None
+
+        client = self._context.vellum_client
+        response = client.workflows.retrieve_state(
+            span_id=previous_execution_id,
+        )
+
+        if response.state is None:
+            return None
+
+        if (
+            response.previous_trace_id is None
+            or response.root_trace_id is None
+            or response.previous_span_id is None
+            or response.root_span_id is None
+        ):
+            logger.warning("Could not find required execution events for state loading")
+            return None
+
+        if "meta" in response.state:
+            response.state.pop("meta")
+
+        if self._workflow_class:
+            state_class = self._workflow_class.get_state_class()
+            state = self._deserialize_state(response.state, state_class)
+        else:
+            logger.warning("No workflow class registered, falling back to BaseState")
+            state = BaseState(**response.state)
+
+        return LoadStateResult(
+            state=state,
+            previous_trace_id=response.previous_trace_id,
+            previous_span_id=response.previous_span_id,
+            root_trace_id=response.root_trace_id,
+            root_span_id=response.root_span_id,
+        )

{vellum_ai-1.7.0 → vellum_ai-1.7.1}/src/vellum/workflows/resolvers/tests/test_resolver.py

@@ -4,14 +4,7 @@ from uuid import uuid4
 from typing import List
 
 from vellum import ChatMessage
-from vellum.client.types.span_link import SpanLink
-from vellum.client.types.vellum_code_resource_definition import VellumCodeResourceDefinition
-from vellum.client.types.workflow_execution_detail import WorkflowExecutionDetail
-from vellum.client.types.workflow_execution_initiated_body import WorkflowExecutionInitiatedBody
-from vellum.client.types.workflow_execution_initiated_event import WorkflowExecutionInitiatedEvent
-from vellum.client.types.workflow_execution_span import WorkflowExecutionSpan
-from vellum.client.types.workflow_execution_span_attributes import WorkflowExecutionSpanAttributes
-from vellum.client.types.workflow_parent_context import WorkflowParentContext
+from vellum.client.types.workflow_resolved_state import WorkflowResolvedState
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.resolvers.resolver import VellumResolver
@@ -24,7 +17,6 @@ def test_load_state_with_context_success():
     """Test load_state successfully loads state when context and client are available."""
     resolver = VellumResolver()
     execution_id = uuid4()
-    root_execution_id = uuid4()
 
     class TestState(BaseState):
         test_key: str = "test_value"
@@ -50,60 +42,24 @@ def test_load_state_with_context_success():
         },
     }
 
-    mock_workflow_definition = VellumCodeResourceDefinition(
-        name="TestWorkflow", module=["test", "module"], id=str(uuid4())
-    )
-
-    mock_body = WorkflowExecutionInitiatedBody(workflow_definition=mock_workflow_definition, inputs={})
-
     previous_trace_id = str(uuid4())
+    previous_span_id = str(uuid4())
     root_trace_id = str(uuid4())
+    root_span_id = str(uuid4())
 
-    previous_invocation = WorkflowExecutionInitiatedEvent(
-        id=str(uuid4()),
+    mock_response = WorkflowResolvedState(
+        trace_id=str(uuid4()),
         timestamp=datetime.now(),
-        trace_id=previous_trace_id,
         span_id=str(execution_id),
-        body=mock_body,
-        links=[
-            SpanLink(
-                trace_id=previous_trace_id,
-                type="PREVIOUS_SPAN",
-                span_context=WorkflowParentContext(workflow_definition=mock_workflow_definition, span_id=str(uuid4())),
-            ),
-            SpanLink(
-                trace_id=root_trace_id,
-                type="ROOT_SPAN",
-                span_context=WorkflowParentContext(
-                    workflow_definition=mock_workflow_definition, span_id=str(root_execution_id)
-                ),
-            ),
-        ],
-    )
-
-    root_invocation = WorkflowExecutionInitiatedEvent(
-        id=str(uuid4()),
-        timestamp=datetime.now(),
-        trace_id=root_trace_id,
-        span_id=str(root_execution_id),
-        body=mock_body,
-        links=None,  # Root invocation has no links
-    )
-
-    mock_span = WorkflowExecutionSpan(
-        span_id=str(execution_id),  # Use the actual execution_id
-        start_ts=datetime.now(),
-        end_ts=datetime.now(),
-        attributes=WorkflowExecutionSpanAttributes(label="Test Workflow", workflow_id=str(uuid4())),
-        events=[previous_invocation, root_invocation],
-    )
-
-    mock_response = WorkflowExecutionDetail(
-        span_id="test-span-id", start=datetime.now(), inputs=[], outputs=[], spans=[mock_span], state=state_dict
+        state=state_dict,
+        previous_trace_id=previous_trace_id,
+        previous_span_id=previous_span_id,
+        root_trace_id=root_trace_id,
+        root_span_id=root_span_id,
     )
 
     mock_client = Mock()
-    mock_client.workflow_executions.retrieve_workflow_execution_detail.return_value = mock_response
+    mock_client.workflows.retrieve_state.return_value = mock_response
 
     # AND context with the test workflow class is set up
     context = WorkflowContext(vellum_client=mock_client)
@@ -123,21 +79,18 @@ def test_load_state_with_context_success():
     assert str(result.state.meta.span_id) != prev_span_id
 
     # AND should have span link info
-    assert result.previous_trace_id == previous_invocation.trace_id
-    assert result.previous_span_id == previous_invocation.span_id
-    assert result.root_trace_id == root_invocation.trace_id
-    assert result.root_span_id == root_invocation.span_id
+    assert result.previous_trace_id == previous_trace_id
+    assert result.previous_span_id == previous_span_id
+    assert result.root_trace_id == root_trace_id
+    assert result.root_span_id == root_span_id
 
-    mock_client.workflow_executions.retrieve_workflow_execution_detail.assert_called_once_with(
-        execution_id=str(execution_id)
-    )
+    mock_client.workflows.retrieve_state.assert_called_once_with(span_id=str(execution_id))
 
 
 def test_load_state_with_chat_message_list():
     """Test load_state successfully loads state with chat_history containing ChatMessage list."""
     resolver = VellumResolver()
     execution_id = uuid4()
-    root_execution_id = uuid4()
 
     class TestStateWithChatHistory(BaseState):
         test_key: str = "test_value"
@@ -169,60 +122,24 @@ def test_load_state_with_chat_message_list():
         },
     }
 
-    mock_workflow_definition = VellumCodeResourceDefinition(
-        name="TestWorkflow", module=["test", "module"], id=str(uuid4())
-    )
-
-    mock_body = WorkflowExecutionInitiatedBody(workflow_definition=mock_workflow_definition, inputs={})
-
     previous_trace_id = str(uuid4())
+    previous_span_id = str(uuid4())
     root_trace_id = str(uuid4())
+    root_span_id = str(uuid4())
 
-    previous_invocation = WorkflowExecutionInitiatedEvent(
-        id=str(uuid4()),
-        timestamp=datetime.now(),
-        trace_id=previous_trace_id,
-        span_id=str(execution_id),
-        body=mock_body,
-        links=[
-            SpanLink(
-                trace_id=previous_trace_id,
-                type="PREVIOUS_SPAN",
-                span_context=WorkflowParentContext(workflow_definition=mock_workflow_definition, span_id=str(uuid4())),
-            ),
-            SpanLink(
-                trace_id=root_trace_id,
-                type="ROOT_SPAN",
-                span_context=WorkflowParentContext(
-                    workflow_definition=mock_workflow_definition, span_id=str(root_execution_id)
-                ),
-            ),
-        ],
-    )
-
-    root_invocation = WorkflowExecutionInitiatedEvent(
-        id=str(uuid4()),
+    mock_response = WorkflowResolvedState(
+        trace_id=str(uuid4()),
         timestamp=datetime.now(),
-        trace_id=root_trace_id,
-        span_id=str(root_execution_id),
-        body=mock_body,
-        links=None,
-    )
-
-    mock_span = WorkflowExecutionSpan(
         span_id=str(execution_id),
-        start_ts=datetime.now(),
-        end_ts=datetime.now(),
-        attributes=WorkflowExecutionSpanAttributes(label="Test Workflow", workflow_id=str(uuid4())),
-        events=[previous_invocation, root_invocation],
-    )
-
-    mock_response = WorkflowExecutionDetail(
-        span_id="test-span-id", start=datetime.now(), inputs=[], outputs=[], spans=[mock_span], state=state_dict
+        state=state_dict,
+        previous_trace_id=previous_trace_id,
+        previous_span_id=previous_span_id,
+        root_trace_id=root_trace_id,
+        root_span_id=root_span_id,
     )
 
     mock_client = Mock()
-    mock_client.workflow_executions.retrieve_workflow_execution_detail.return_value = mock_response
+    mock_client.workflows.retrieve_state.return_value = mock_response
 
     # AND context with the test workflow class is set up
     context = WorkflowContext(vellum_client=mock_client)
@@ -247,6 +164,4 @@ def test_load_state_with_chat_message_list():
     assert result.state.chat_history[2].role == "USER"
     assert result.state.chat_history[2].text == "What can you help me with?"
 
-    mock_client.workflow_executions.retrieve_workflow_execution_detail.assert_called_once_with(
-        execution_id=str(execution_id)
-    )
+    mock_client.workflows.retrieve_state.assert_called_once_with(span_id=str(execution_id))

vellum_ai-1.7.0/src/vellum/workflows/resolvers/resolver.py

@@ -1,113 +0,0 @@
-import logging
-from uuid import UUID
-from typing import Iterator, List, Optional, Tuple, Type, Union
-
-from vellum.client.types.vellum_span import VellumSpan
-from vellum.client.types.workflow_execution_initiated_event import WorkflowExecutionInitiatedEvent
-from vellum.workflows.events.workflow import WorkflowEvent
-from vellum.workflows.nodes.utils import cast_to_output_type
-from vellum.workflows.resolvers.base import BaseWorkflowResolver
-from vellum.workflows.resolvers.types import LoadStateResult
-from vellum.workflows.state.base import BaseState
-
-logger = logging.getLogger(__name__)
-
-
-class VellumResolver(BaseWorkflowResolver):
-    def get_latest_execution_events(self) -> Iterator[WorkflowEvent]:
-        return iter([])
-
-    def get_state_snapshot_history(self) -> Iterator[BaseState]:
-        return iter([])
-
-    def _find_previous_and_root_span(
-        self, execution_id: str, spans: List[VellumSpan]
-    ) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str]]:
-        previous_trace_id: Optional[str] = None
-        root_trace_id: Optional[str] = None
-        previous_span_id: Optional[str] = None
-        root_span_id: Optional[str] = None
-
-        for span in spans:
-            # Look for workflow execution spans with matching ID first
-            if span.name == "workflow.execution" and span.span_id == execution_id:
-                # Find the WorkflowExecutionInitiatedEvent in the span's events
-                initiated_event = next(
-                    (event for event in span.events if isinstance(event, WorkflowExecutionInitiatedEvent)), None
-                )
-                if initiated_event:
-                    previous_trace_id = initiated_event.trace_id
-                    previous_span_id = initiated_event.span_id
-                    links = initiated_event.links
-                    if links:
-                        root_span = next((link for link in links if link.type == "ROOT_SPAN"), None)
-                        if root_span:
-                            root_trace_id = root_span.trace_id
-                            root_span_id = root_span.span_context.span_id
-                    else:
-                        # no links means this is the first execution
-                        root_trace_id = initiated_event.trace_id
-                        root_span_id = initiated_event.span_id
-                    break
-
-        return previous_trace_id, root_trace_id, previous_span_id, root_span_id
-
-    def _deserialize_state(self, state_data: dict, state_class: Type[BaseState]) -> BaseState:
-        """Deserialize state data with proper type conversion for complex types like List[ChatMessage]."""
-        converted_data = {}
-
-        annotations = getattr(state_class, "__annotations__", {})
-
-        for field_name, field_value in state_data.items():
-            if field_name in annotations:
-                field_type = annotations[field_name]
-                converted_data[field_name] = cast_to_output_type(field_value, field_type)
-            else:
-                converted_data[field_name] = field_value
-
-        return state_class(**converted_data)
-
-    def load_state(self, previous_execution_id: Optional[Union[UUID, str]] = None) -> Optional[LoadStateResult]:
-        if isinstance(previous_execution_id, UUID):
-            previous_execution_id = str(previous_execution_id)
-
-        if previous_execution_id is None:
-            return None
-
-        if not self._context:
-            logger.warning("Cannot load state: No workflow context registered")
-            return None
-
-        client = self._context.vellum_client
-        response = client.workflow_executions.retrieve_workflow_execution_detail(
-            execution_id=previous_execution_id,
-        )
-
-        if response.state is None:
-            return None
-
-        previous_trace_id, root_trace_id, previous_span_id, root_span_id = self._find_previous_and_root_span(
-            previous_execution_id, response.spans
-        )
-
-        if previous_trace_id is None or root_trace_id is None or previous_span_id is None or root_span_id is None:
-            logger.warning("Could not find required execution events for state loading")
-            return None
-
-        if "meta" in response.state:
-            response.state.pop("meta")
-
-        if self._workflow_class:
-            state_class = self._workflow_class.get_state_class()
-            state = self._deserialize_state(response.state, state_class)
-        else:
-            logger.warning("No workflow class registered, falling back to BaseState")
-            state = BaseState(**response.state)
-
-        return LoadStateResult(
-            state=state,
-            previous_trace_id=previous_trace_id,
-            previous_span_id=previous_span_id,
-            root_trace_id=root_trace_id,
-            root_span_id=root_span_id,
-        )