vellum-ai 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

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

@@ -1,10 +1,10 @@
-import json
 from typing import Any, Dict, Generic, Iterator, Type, Union
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BaseInlinePromptNode as BaseInlinePromptNode
+from vellum.workflows.nodes.displayable.bases.utils import process_additional_prompt_outputs
 from vellum.workflows.outputs import BaseOutput
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
@@ -45,31 +45,8 @@ class InlinePromptNode(BaseInlinePromptNode[StateType], Generic[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_outputs = []
-        json_output = None
-
-        for output in outputs:
-            if output.value is None:
-                continue
-
-            if output.type == "STRING":
-                string_outputs.append(output.value)
-                try:
-                    json_output = json.loads(output.value)
-                except (json.JSONDecodeError, TypeError):
-                    pass
-            elif output.type == "JSON":
-                string_outputs.append(json.dumps(output.value, indent=4))
-                json_output = output.value
-            elif output.type == "FUNCTION_CALL":
-                string_outputs.append(output.value.model_dump_json(indent=4))
-            elif output.type == "THINKING":
-                continue
-            else:
-                string_outputs.append(output.value.message)
-
-        value = "\n".join(string_outputs)
-        yield BaseOutput(name="text", value=value)
+        text_output, json_output = process_additional_prompt_outputs(outputs)
+        yield BaseOutput(name="text", value=text_output)
 
         if json_output:
             yield BaseOutput(name="json", value=json_output)

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

@@ -1,10 +1,10 @@
-import json
 from typing import Any, Dict, Iterator, Type, Union
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BasePromptDeploymentNode as BasePromptDeploymentNode
+from vellum.workflows.nodes.displayable.bases.utils import process_additional_prompt_outputs
 from vellum.workflows.outputs import BaseOutput
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
@@ -48,30 +48,8 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_outputs = []
-        json_output = None
-
-        for output in outputs:
-            if output.value is None:
-                continue
-
-            if output.type == "STRING":
-                string_outputs.append(output.value)
-                try:
-                    json_output = json.loads(output.value)
-                except (json.JSONDecodeError, TypeError):
-                    pass
-            elif output.type == "JSON":
-                string_outputs.append(json.dumps(output.value, indent=4))
-            elif output.type == "FUNCTION_CALL":
-                string_outputs.append(output.value.model_dump_json(indent=4))
-            elif output.type == "THINKING":
-                continue
-            else:
-                string_outputs.append(output.value.message)
-
-        value = "\n".join(string_outputs)
-        yield BaseOutput(name="text", value=value)
+        text_output, json_output = process_additional_prompt_outputs(outputs)
+        yield BaseOutput(name="text", value=text_output)
 
         if json_output:
             yield BaseOutput(name="json", value=json_output)

vellum/workflows/nodes/utils.py

@@ -15,7 +15,12 @@ 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.state.base import BaseState
-from vellum.workflows.types.code_execution_node_wrappers import DictWrapper, ListWrapper, StringValueWrapper
+from vellum.workflows.types.code_execution_node_wrappers import (
+    DictWrapper,
+    ListWrapper,
+    StringValueWrapper,
+    clean_for_dict_wrapper,
+)
 from vellum.workflows.types.core import Json
 from vellum.workflows.types.generics import NodeType
 
@@ -261,3 +266,23 @@ def cast_to_output_type(result: Any, output_type: Any) -> Any:
             code=WorkflowErrorCode.INVALID_OUTPUTS,
             message=f"Expected an output of type '{output_type_name}', but received '{result_type_name}'",
         )
+
+
+def wrap_inputs_for_backward_compatibility(inputs: Dict[str, Any]) -> Dict[str, Any]:
+    """Wrap inputs with backward-compatible wrapper classes for legacy .value and .type support."""
+
+    def _wrap_single_value(value: Any) -> Any:
+        if isinstance(value, list):
+            return ListWrapper(
+                [
+                    (
+                        item.model_dump()
+                        if isinstance(item, BaseModel)
+                        else clean_for_dict_wrapper(item) if isinstance(item, (dict, list, str)) else item
+                    )
+                    for item in value
+                ]
+            )
+        return clean_for_dict_wrapper(value)
+
+    return {name: _wrap_single_value(value) for name, value in inputs.items()}

vellum/workflows/resolvers/base.py

@@ -1,11 +1,24 @@
 from abc import ABC, abstractmethod
-from typing import Iterator
+from uuid import UUID
+from typing import TYPE_CHECKING, Iterator, Optional, Type
 
 from vellum.workflows.events.workflow import WorkflowEvent
 from vellum.workflows.state.base import BaseState
 
+if TYPE_CHECKING:
+    from vellum.workflows.state.context import WorkflowContext
+    from vellum.workflows.workflows.base import BaseWorkflow
+
 
 class BaseWorkflowResolver(ABC):
+    def __init__(self):
+        self._context: Optional["WorkflowContext"] = None
+        self._workflow_class: Optional[Type["BaseWorkflow"]] = None
+
+    def register_workflow_instance(self, workflow_instance: "BaseWorkflow") -> None:
+        self._workflow_class = type(workflow_instance)
+        self._context = workflow_instance.context
+
     @abstractmethod
     def get_latest_execution_events(self) -> Iterator[WorkflowEvent]:
         pass
@@ -13,3 +26,7 @@ class BaseWorkflowResolver(ABC):
     @abstractmethod
     def get_state_snapshot_history(self) -> Iterator[BaseState]:
         pass
+
+    @abstractmethod
+    def load_state(self, previous_execution_id: Optional[UUID] = None) -> Optional[BaseState]:
+        pass

vellum/workflows/resolvers/resolver.py

@@ -0,0 +1,42 @@
+import logging
+from uuid import UUID
+from typing import Iterator, Optional
+
+from vellum.workflows.events.workflow import WorkflowEvent
+from vellum.workflows.resolvers.base import BaseWorkflowResolver
+from vellum.workflows.state.base import BaseState, StateMeta
+
+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 load_state(self, previous_execution_id: Optional[UUID] = None) -> Optional[BaseState]:
+        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=str(previous_execution_id),
+        )
+
+        if response.state is None:
+            return None
+
+        meta = StateMeta.model_validate(response.state.pop("meta"))
+
+        if self._workflow_class:
+            state_class = self._workflow_class.get_state_class()
+            return state_class(**response.state, meta=meta)
+        else:
+            logger.warning("No workflow class registered, falling back to BaseState")
+            return BaseState(**response.state, meta=meta)

vellum/workflows/resolvers/tests/test_resolver.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+from unittest.mock import Mock
+from uuid import uuid4
+
+from vellum.client.types.workflow_execution_detail import WorkflowExecutionDetail
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.resolvers.resolver import VellumResolver
+from vellum.workflows.state.base import BaseState, NodeExecutionCache
+from vellum.workflows.state.context import WorkflowContext
+
+
+def test_load_state_with_context_success():
+    """Test load_state successfully loads state when context and client are available."""
+    resolver = VellumResolver()
+    execution_id = uuid4()
+
+    class TestState(BaseState):
+        test_key: str = "test_value"
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, TestState]):
+        pass
+
+    # GIVEN a state dictionary that matches what the resolver expects
+    state_dict = {
+        "test_key": "test_value",
+        "meta": {
+            "workflow_definition": "MockWorkflow",
+            "id": str(uuid4()),
+            "span_id": str(uuid4()),
+            "updated_ts": datetime.now().isoformat(),
+            "workflow_inputs": BaseInputs(),
+            "external_inputs": {},
+            "node_outputs": {},
+            "node_execution_cache": NodeExecutionCache(),
+            "parent": None,
+        },
+    }
+
+    mock_response = WorkflowExecutionDetail(
+        span_id="test-span-id", start=datetime.now(), inputs=[], outputs=[], spans=[], state=state_dict
+    )
+
+    mock_client = Mock()
+    mock_client.workflow_executions.retrieve_workflow_execution_detail.return_value = mock_response
+
+    # AND context with the test workflow class
+    context = WorkflowContext(vellum_client=mock_client)
+    TestWorkflow(context=context, resolvers=[resolver])
+
+    result = resolver.load_state(previous_execution_id=execution_id)
+
+    # THEN should return an instance of TestWorkflow.State, not BaseState
+    assert isinstance(result, TestState)
+    assert result.test_key == "test_value"
+
+    mock_client.workflow_executions.retrieve_workflow_execution_detail.assert_called_once_with(
+        execution_id=str(execution_id)
+    )

vellum/workflows/types/definition.py

@@ -121,6 +121,7 @@ class ComposioToolDefinition(UniversalBaseModel):
 class MCPServer(UniversalBaseModel):
     type: Literal["MCP_SERVER"] = "MCP_SERVER"
     name: str
+    description: str = ""  # We don't use this field, its for compatibility with UI
     url: str
     authorization_type: Optional[AuthorizationType] = None
     bearer_token_value: Optional[Union[str, EnvironmentVariableReference]] = None

vellum/workflows/utils/functions.py

@@ -89,6 +89,10 @@ def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
                 # 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 hasattr(field, "description") and field.description is not None:
+                    properties[field_name]["description"] = field.description  # type: ignore[attr-defined]
+
                 if field.default is PydanticUndefined:
                     required.append(field_name)
                 else:

vellum/workflows/utils/tests/test_functions.py

@@ -4,7 +4,7 @@ from enum import Enum
 from unittest.mock import Mock
 from typing import Annotated, Dict, List, Literal, Optional, Tuple, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from vellum.client.types.function_definition import FunctionDefinition
 from vellum.client.types.string_vellum_value import StringVellumValue
@@ -206,7 +206,7 @@ def test_compile_function_definition__dataclasses():
 def test_compile_function_definition__pydantic():
     # GIVEN a function with a pydantic model
     class MyPydanticModel(BaseModel):
-        a: int
+        a: int = Field(description="The first number")
         b: str
 
     def my_function(c: MyPydanticModel):
@@ -225,7 +225,10 @@ def test_compile_function_definition__pydantic():
             "$defs": {
                 "MyPydanticModel": {
                     "type": "object",
-                    "properties": {"a": {"type": "integer"}, "b": {"type": "string"}},
+                    "properties": {
+                        "a": {"type": "integer", "description": "The first number"},
+                        "b": {"type": "string"},
+                    },
                     "required": ["a", "b"],
                 }
             },

vellum/workflows/workflows/base.py

@@ -251,6 +251,9 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         for emitter in self.emitters:
             emitter.register_context(self._context)
 
+        for resolver in self.resolvers:
+            resolver.register_workflow_instance(self)
+
         self.validate()
 
     @property

{vellum_ai-1.2.3.dist-info → vellum_ai-1.2.5.dist-info}/METADATA

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