vellum-ai 0.10.3__tar.gz → 0.10.4__tar.gz

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/PKG-INFO

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

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/ee/vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -7,16 +7,15 @@ from vellum import (
     VellumValueLogicalConditionGroupRequest,
     VellumValueLogicalConditionRequest,
 )
-
+from vellum.workflows.nodes.displayable.search_node import SearchNode
+from vellum.workflows.references import OutputReference
+from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.vellum import NodeInput
-from vellum.workflows.nodes.displayable.search_node import SearchNode
-from vellum.workflows.references import OutputReference
-from vellum.workflows.types.core import JsonArray, JsonObject
 
 _SearchNodeType = TypeVar("_SearchNodeType", bound=SearchNode)
 
@@ -76,10 +75,7 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
         options = raise_if_descriptor(node.options)
         filters = options.filters if options else None
 
-        if filters and filters.external_ids:
-            # TODO: Add support for serializing external ID filters
-            # https://app.shortcut.com/vellum/story/5563/add-support-for-serializing-external-id-in-text-search-nodes
-            raise NotImplementedError("Serializing External ID filters is not yet supported")
+        external_id_filters = filters.external_ids if filters else None
 
         raw_metadata_filters = filters.metadata if filters else None
         metadata_filters = None
@@ -108,7 +104,7 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                 "result_merging_enabled",
                 ("True" if result_merging_enabled else "False"),
             ),
-            ("external_id_filters", None),
+            ("external_id_filters", external_id_filters),
             ("metadata_filters", metadata_filters),
         ]
 

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/ee/vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -1,19 +1,18 @@
 from uuid import UUID
 from typing import Any, ClassVar, Dict, Generic, Optional, TypeVar
 
+from vellum.workflows.nodes.core.templating_node import TemplatingNode
+from vellum.workflows.types.core import JsonObject
+from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
-from vellum.workflows.nodes.core.templating_node import TemplatingNode
-from vellum.workflows.types.core import JsonObject
-from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 
 _TemplatingNodeType = TypeVar("_TemplatingNodeType", bound=TemplatingNode)
 
 
 class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Generic[_TemplatingNodeType]):
-    output_id: ClassVar[Optional[UUID]] = None
     template_input_id: ClassVar[Optional[UUID]] = None
     input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/pyproject.toml

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

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/src/vellum/client/core/client_wrapper.py

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

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/src/vellum/workflows/events/tests/test_event.py

@@ -7,6 +7,7 @@ from deepdiff import DeepDiff
 
 from vellum.workflows.errors.types import VellumError, VellumErrorCode
 from vellum.workflows.events.node import NodeExecutionInitiatedBody, NodeExecutionInitiatedEvent
+from vellum.workflows.events.types import NodeParentContext, WorkflowParentContext
 from vellum.workflows.events.workflow import (
     WorkflowExecutionFulfilledBody,
     WorkflowExecutionFulfilledEvent,
@@ -73,6 +74,7 @@ module_root = name_parts[: name_parts.index("events")]
                         "foo": "bar",
                     },
                 },
+                "parent": None,
             },
         ),
         (
@@ -87,6 +89,14 @@ module_root = name_parts[: name_parts.index("events")]
                         MockNode.node_foo: "bar",
                     },
                 ),
+                parent=NodeParentContext(
+                    node_definition=MockNode,
+                    span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                    parent=WorkflowParentContext(
+                        workflow_definition=MockWorkflow,
+                        span_id=UUID("123e4567-e89b-12d3-a456-426614174000")
+                    )
+                )
             ),
             {
                 "id": "123e4567-e89b-12d3-a456-426614174000",
@@ -104,6 +114,23 @@ module_root = name_parts[: name_parts.index("events")]
                         "node_foo": "bar",
                     },
                 },
+                "parent": {
+                    "node_definition": {
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "parent": {
+                        "workflow_definition": {
+                            "name": "MockWorkflow",
+                            "module": module_root + ["events", "tests", "test_event"],
+                        },
+                        "type": "WORKFLOW",
+                        "parent": None,
+                        "span_id": "123e4567-e89b-12d3-a456-426614174000"
+                    },
+                    "type": "WORKFLOW_NODE",
+                    "span_id": "123e4567-e89b-12d3-a456-426614174000"
+                },
             },
         ),
         (
@@ -137,6 +164,7 @@ module_root = name_parts[: name_parts.index("events")]
                         "value": "foo",
                     },
                 },
+                "parent": None
             },
         ),
         (
@@ -168,6 +196,7 @@ module_root = name_parts[: name_parts.index("events")]
                         "example": "foo",
                     },
                 },
+                "parent": None,
             },
         ),
         (
@@ -201,6 +230,7 @@ module_root = name_parts[: name_parts.index("events")]
                         "code": "USER_DEFINED_ERROR",
                     },
                 },
+                "parent": None,
             },
         ),
     ],

vellum_ai-0.10.4/src/vellum/workflows/events/types.py

@@ -0,0 +1,106 @@
+from datetime import datetime
+from enum import Enum
+import json
+from uuid import UUID, uuid4
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Type, Union
+
+from pydantic import Field, field_serializer
+
+from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.workflows.state.encoder import DefaultStateEncoder
+from vellum.workflows.types.utils import datetime_now
+
+if TYPE_CHECKING:
+    from vellum.workflows.nodes.bases.base import BaseNode
+    from vellum.workflows.workflows.base import BaseWorkflow
+
+
+class WorkflowEventType(Enum):
+    NODE = "NODE"
+    WORKFLOW = "WORKFLOW"
+
+
+def default_datetime_factory() -> datetime:
+    """
+    Makes it possible to mock the datetime factory for testing.
+    """
+
+    return datetime_now()
+
+
+excluded_modules = {"typing", "builtins"}
+
+
+def serialize_type_encoder(obj: type) -> Dict[str, Any]:
+    return {
+        "name": obj.__name__,
+        "module": obj.__module__.split("."),
+    }
+
+
+def default_serializer(obj: Any) -> Any:
+    return json.loads(
+        json.dumps(
+            obj,
+            cls=DefaultStateEncoder,
+        )
+    )
+
+
+class BaseParentContext(UniversalBaseModel):
+    span_id: UUID
+    parent: Optional['ParentContext'] = None
+
+
+class BaseDeploymentParentContext(BaseParentContext):
+    deployment_id: UUID
+    deployment_name: str
+    deployment_history_item_id: UUID
+    release_tag_id: UUID
+    release_tag_name: str
+    external_id: Optional[str]
+
+
+class WorkflowDeploymentParentContext(BaseDeploymentParentContext):
+    type: Literal["WORKFLOW_RELEASE_TAG"] = "WORKFLOW_RELEASE_TAG"
+    workflow_version_id: UUID
+
+
+class PromptDeploymentParentContext(BaseDeploymentParentContext):
+    type: Literal["PROMPT_RELEASE_TAG"] = "PROMPT_RELEASE_TAG"
+    prompt_version_id: UUID
+
+
+class NodeParentContext(BaseParentContext):
+    type: Literal["WORKFLOW_NODE"] = "WORKFLOW_NODE"
+    node_definition: Type['BaseNode']
+
+    @field_serializer("node_definition")
+    def serialize_node_definition(self, definition: Type, _info: Any) -> Dict[str, Any]:
+        return serialize_type_encoder(definition)
+
+
+class WorkflowParentContext(BaseParentContext):
+    type: Literal["WORKFLOW"] = "WORKFLOW"
+    workflow_definition: Type['BaseWorkflow']
+
+    @field_serializer("workflow_definition")
+    def serialize_workflow_definition(self, definition: Type, _info: Any) -> Dict[str, Any]:
+        return serialize_type_encoder(definition)
+
+
+ParentContext = Union[
+    NodeParentContext,
+    WorkflowParentContext,
+    PromptDeploymentParentContext,
+    WorkflowDeploymentParentContext,
+]
+
+
+class BaseEvent(UniversalBaseModel):
+    id: UUID = Field(default_factory=uuid4)
+    timestamp: datetime = Field(default_factory=default_datetime_factory)
+    api_version: Literal["2024-10-25"] = "2024-10-25"
+    trace_id: UUID
+    span_id: UUID
+    parent: Optional['ParentContext'] = None

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/src/vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -25,6 +25,7 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
     def run(self) -> Iterator[BaseOutput]:
         subworkflow = self.subworkflow(
             parent_state=self.state,
+            context=self._context,
         )
         subworkflow_stream = subworkflow.stream(
             inputs=self._compile_subworkflow_inputs(),

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/src/vellum/workflows/nodes/core/map_node/node.py

@@ -89,7 +89,7 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
         return self.Outputs(**mapped_items)
 
     def _run_subworkflow(self, *, item: MapNodeItemType, index: int) -> None:
-        subworkflow = self.subworkflow(parent_state=self.state)
+        subworkflow = self.subworkflow(parent_state=self.state, context=self._context)
         events = subworkflow.stream(inputs=self.SubworkflowInputs(index=index, item=item, all_items=self.items))
 
         for event in events:

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/src/vellum/workflows/nodes/core/retry_node/node.py

@@ -43,6 +43,7 @@ class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMet
             attempt_number = index + 1
             subworkflow = self.subworkflow(
                 parent_state=self.state,
+                context=self._context,
             )
             terminal_event = subworkflow.run(
                 inputs=self.SubworkflowInputs(attempt_number=attempt_number),

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/src/vellum/workflows/nodes/core/try_node/node.py

@@ -59,6 +59,7 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     def run(self) -> Outputs:
         subworkflow = self.subworkflow(
             parent_state=self.state,
+            context=self._context,
         )
         terminal_event = subworkflow.run()
 

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/src/vellum/workflows/nodes/core/try_node/tests/test_node.py

@@ -1,5 +1,6 @@
 import pytest
 
+from vellum.client import Vellum
 from vellum.workflows.errors.types import VellumError, VellumErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
@@ -7,6 +8,7 @@ from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
+from vellum.workflows.state.context import WorkflowContext
 
 
 def test_try_node__on_error_code__successfully_caught():
@@ -80,3 +82,25 @@ def test_try_node__use_parent_inputs_and_state():
 
     # THEN the data is used successfully
     assert outputs == {"value": "foo bar"}
+
+
+def test_try_node__use_parent_execution_context():
+    # GIVEN a try node that uses node context to use the vellum client
+    @TryNode.wrap()
+    class TestNode(BaseNode):
+        class Outputs(BaseOutputs):
+            key: str
+
+        def run(self) -> Outputs:
+            return self.Outputs(key=self._context.vellum_client.ad_hoc._client_wrapper.api_key)
+
+    # WHEN the node is run with a custom vellum client
+    node = TestNode(
+        context=WorkflowContext(
+            _vellum_client=Vellum(api_key="test-key"),
+        )
+    )
+    outputs = node.run()
+
+    # THEN the inner node had access to the key
+    assert outputs == {"key": "test-key"}

{vellum_ai-0.10.3 → vellum_ai-0.10.4}/src/vellum/workflows/state/tests/test_state.py

@@ -1,3 +1,4 @@
+import pytest
 from collections import defaultdict
 from copy import deepcopy
 import json
@@ -76,6 +77,7 @@ def test_state_deepcopy():
     assert deepcopied_state.meta.node_outputs == state.meta.node_outputs
 
 
+@pytest.mark.skip(reason="https://app.shortcut.com/vellum/story/5654")
 def test_state_deepcopy__with_node_output_updates():
     # GIVEN an initial state instance
     state = MockState(foo="bar")

vellum_ai-0.10.3/src/vellum/workflows/events/types.py

@@ -1,52 +0,0 @@
-from datetime import datetime
-from enum import Enum
-import json
-from uuid import UUID, uuid4
-from typing import Any, Dict, Literal
-
-from pydantic import Field
-
-from vellum.core.pydantic_utilities import UniversalBaseModel
-
-from vellum.workflows.state.encoder import DefaultStateEncoder
-from vellum.workflows.types.utils import datetime_now
-
-
-class WorkflowEventType(Enum):
-    NODE = "NODE"
-    WORKFLOW = "WORKFLOW"
-
-
-def default_datetime_factory() -> datetime:
-    """
-    Makes it possible to mock the datetime factory for testing.
-    """
-
-    return datetime_now()
-
-
-excluded_modules = {"typing", "builtins"}
-
-
-def serialize_type_encoder(obj: type) -> Dict[str, Any]:
-    return {
-        "name": obj.__name__,
-        "module": obj.__module__.split("."),
-    }
-
-
-def default_serializer(obj: Any) -> Any:
-    return json.loads(
-        json.dumps(
-            obj,
-            cls=DefaultStateEncoder,
-        )
-    )
-
-
-class BaseEvent(UniversalBaseModel):
-    id: UUID = Field(default_factory=uuid4)
-    timestamp: datetime = Field(default_factory=default_datetime_factory)
-    api_version: Literal["2024-10-25"] = "2024-10-25"
-    trace_id: UUID
-    span_id: UUID