vellum-ai 0.13.27__tar.gz → 0.13.28__tar.gz

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.13.27
+Version: 0.13.28
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0
@@ -37,6 +37,7 @@ Requires-Dist: pyyaml (==6.0.1)
 Requires-Dist: requests (==2.32.3)
 Requires-Dist: tomli (==2.0.2)
 Requires-Dist: typing_extensions (>=4.0.0)
+Project-URL: Repository, https://github.com/vellum-ai/vellum-python-sdks
 Description-Content-Type: text/markdown
 
 <p align="center">

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/ee/vellum_cli/push.py

@@ -53,7 +53,16 @@ def push_command(
         workflow_configs = [w for w in workflow_configs if w.workspace == workspace]
 
     if len(workflow_configs) == 0:
-        raise ValueError(f"No workflow config for '{module}' found in project to push.")
+        if module and module_exists(module):
+            new_config = WorkflowConfig(
+                module=module,
+                workflow_sandbox_id=workflow_sandbox_id,
+                workspace=workspace or DEFAULT_WORKSPACE_CONFIG.name,
+            )
+            config.workflows.append(new_config)
+            workflow_configs = [new_config]
+        else:
+            raise ValueError(f"No workflow config for '{module}' found in project to push.")
 
     if len(workflow_configs) > 1:
         raise ValueError("Multiple workflows found in project to push. Pushing only a single workflow is supported.")
@@ -241,3 +250,8 @@ Visit at: https://app.vellum.ai/workflow-sandboxes/{response.workflow_sandbox_id
 
     config.save()
     logger.info("Updated vellum.lock.json file.")
+
+
+def module_exists(module_name: str) -> bool:
+    module_path = os.path.join(os.getcwd(), *module_name.split("."))
+    return os.path.exists(module_path) and os.path.isdir(module_path)

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/ee/vellum_cli/tests/test_push.py

@@ -589,3 +589,47 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
         assert lock_file_content["workflows"][1]["module"] == module
         assert lock_file_content["workflows"][1]["workflow_sandbox_id"] == second_workflow_sandbox_id
         assert lock_file_content["workflows"][1]["workspace"] == "my_other_workspace"
+
+
+def test_push__create_new_config_for_existing_module(mock_module, vellum_client):
+    # GIVEN an empty config (no workflows configured)
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    # GIVEN multiple workflows configured
+    mock_module.set_pyproject_toml({"workflows": [{"module": "examples.mock"}, {"module": "examples.mock2"}]})
+
+    # AND a workflow exists in the module successfully
+    workflow_py_file_content = _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully
+    new_workflow_sandbox_id = str(uuid4())
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=new_workflow_sandbox_id,
+    )
+
+    # WHEN calling `vellum push` with a module that exists but isn't in config
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "push", module])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API with the correct args
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+    assert json.loads(call_args["exec_config"])["workflow_raw_data"]["definition"]["name"] == "ExampleWorkflow"
+    assert call_args["workflow_sandbox_id"] is None  # Should be None since it's a new config
+    assert call_args["artifact"].name == f"{module.replace('.', '__')}.tar.gz"
+
+    # AND the files in the artifact should be correct
+    extracted_files = _extract_tar_gz(call_args["artifact"].read())
+    assert extracted_files["workflow.py"] == workflow_py_file_content
+
+    # AND check that lockfile was updated with new config
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        new_configs = [w for w in lock_file_content["workflows"] if w["module"] == module]
+        assert len(new_configs) == 1  # Should only create one config
+        new_config = new_configs[0]
+        assert new_config["workflow_sandbox_id"] == new_workflow_sandbox_id
+        assert new_config["workspace"] == "default"

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.13.27"
+version = "0.13.28"
 description = ""
 readme = "README.md"
 authors = []
@@ -24,15 +24,13 @@ classifiers = [
     "Typing :: Typed",
     "License :: OSI Approved :: MIT License"
 ]
+urls = { Repository = "https://github.com/vellum-ai/vellum-python-sdks" }
 packages = [
     { include = "vellum", from = "src" },
     { include = "vellum_cli", from = "ee" },
     { include = "vellum_ee", from = "ee" },
 ]
 
-[project.urls]
-Repository = 'https://github.com/vellum-ai/vellum-python-sdks'
-
 [tool.poetry.dependencies]
 python = "^3.9"
 Jinja2 = "^3.1.2"

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/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.13.27",
+            "X-Fern-SDK-Version": "0.13.28",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum_ai-0.13.28/src/vellum/workflows/descriptors/exceptions.py

@@ -0,0 +1,2 @@
+class InvalidExpressionException(Exception):
+    pass

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/accessor.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, GetCoreSchemaHandler
 from pydantic_core import core_schema
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -32,13 +33,13 @@ class AccessorExpression(BaseDescriptor[Any]):
 
         if dataclasses.is_dataclass(base):
             if isinstance(self._field, int):
-                raise ValueError("Cannot access field by index on a dataclass")
+                raise InvalidExpressionException("Cannot access field by index on a dataclass")
 
             return getattr(base, self._field)
 
         if isinstance(base, BaseModel):
             if isinstance(self._field, int):
-                raise ValueError("Cannot access field by index on a BaseModel")
+                raise InvalidExpressionException("Cannot access field by index on a BaseModel")
 
             return getattr(base, self._field)
 
@@ -49,7 +50,7 @@ class AccessorExpression(BaseDescriptor[Any]):
             index = int(self._field)
             return base[index]
 
-        raise ValueError(f"Cannot get field {self._field} from {base}")
+        raise InvalidExpressionException(f"Cannot get field {self._field} from {base}")
 
     @classmethod
     def __get_pydantic_core_schema__(

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/begins_with.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,9 +24,9 @@ class BeginsWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return lhs.startswith(rhs)

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/between.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -25,14 +26,14 @@ class BetweenExpression(BaseDescriptor[bool], Generic[_V, _S, _E]):
     def resolve(self, state: "BaseState") -> bool:
         value = resolve_value(self._value, state)
         if not isinstance(value, (int, float)):
-            raise ValueError(f"Expected a numeric value, got: {value.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric value, got: {value.__class__.__name__}")
 
         start = resolve_value(self._start, state)
         if not isinstance(start, (int, float)):
-            raise ValueError(f"Expected a numeric start value, got: {start.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric start value, got: {start.__class__.__name__}")
 
         end = resolve_value(self._end, state)
         if not isinstance(end, (int, float)):
-            raise ValueError(f"Expected a numeric end value, got: {end.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric end value, got: {end.__class__.__name__}")
 
         return start <= value <= end

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/contains.py

@@ -1,6 +1,8 @@
 from typing import Generic, TypeVar, Union
 
+from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,8 +25,13 @@ class ContainsExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # Support any type that implements the in operator
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
+        # assumes that lack of is also false
+        if lhs is UNDEF:
+            return False
         if not isinstance(lhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a LHS that supported contains, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(
+                f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
+            )
 
         rhs = resolve_value(self._rhs, state)
         return rhs in lhs

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/does_not_begin_with.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,9 +24,9 @@ class DoesNotBeginWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return not lhs.startswith(rhs)

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/does_not_contain.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -24,7 +25,9 @@ class DoesNotContainExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a LHS that supported contains, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(
+                f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
+            )
 
         rhs = resolve_value(self._rhs, state)
         return rhs not in lhs

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/does_not_end_with.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,9 +24,9 @@ class DoesNotEndWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return not lhs.endswith(rhs)

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/ends_with.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,9 +24,9 @@ class EndsWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return lhs.endswith(rhs)

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/greater_than.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -24,10 +25,10 @@ class GreaterThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (int, float)):
-            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs > rhs

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/greater_than_or_equal_to.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -24,10 +25,10 @@ class GreaterThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (int, float)):
-            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs >= rhs

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/in_.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -26,6 +27,6 @@ class InExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a RHS that supported in, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a RHS that supported in, got: {rhs.__class__.__name__}")
 
         return lhs in rhs

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/is_blank.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -19,6 +20,6 @@ class IsBlankExpression(BaseDescriptor[bool], Generic[_T]):
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
         if not isinstance(expression, str):
-            raise ValueError(f"Expected a string expression, got: {expression.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a string expression, got: {expression.__class__.__name__}")
 
         return len(expression) == 0

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/is_not_blank.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -19,6 +20,6 @@ class IsNotBlankExpression(BaseDescriptor[bool], Generic[_T]):
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
         if not isinstance(expression, str):
-            raise ValueError(f"Expected a string expression, got: {expression.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a string expression, got: {expression.__class__.__name__}")
 
         return len(expression) != 0

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/less_than.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -24,10 +25,10 @@ class LessThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (int, float)):
-            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs < rhs

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/less_than_or_equal_to.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -24,10 +25,10 @@ class LessThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (int, float)):
-            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs <= rhs

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/not_between.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -25,14 +26,14 @@ class NotBetweenExpression(BaseDescriptor[bool], Generic[_V, _S, _E]):
     def resolve(self, state: "BaseState") -> bool:
         value = resolve_value(self._value, state)
         if not isinstance(value, (int, float)):
-            raise ValueError(f"Expected a numeric value, got: {value.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric value, got: {value.__class__.__name__}")
 
         start = resolve_value(self._start, state)
         if not isinstance(start, (int, float)):
-            raise ValueError(f"Expected a numeric start value, got: {start.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric start value, got: {start.__class__.__name__}")
 
         end = resolve_value(self._end, state)
         if not isinstance(end, (int, float)):
-            raise ValueError(f"Expected a numeric end value, got: {end.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric end value, got: {end.__class__.__name__}")
 
         return value < start or value > end

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/expressions/not_in.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -26,6 +27,6 @@ class NotInExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a RHS that supported contains, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a RHS that supported contains, got: {rhs.__class__.__name__}")
 
         return lhs not in rhs

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/nodes/bases/base.py

@@ -255,17 +255,15 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 return False
 
             if cls.merge_behavior == MergeBehavior.AWAIT_ATTRIBUTES:
-                is_ready = True
                 for descriptor in cls.node_class:
                     if not descriptor.instance:
                         continue
 
                     resolved_value = resolve_value(descriptor.instance, state, path=descriptor.name)
                     if is_unresolved(resolved_value):
-                        is_ready = False
-                        break
+                        return False
 
-                return is_ready
+                return True
 
             if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
                 return True

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, Generic, Optional, Union
 from requests import Request, RequestException, Session
 from requests.exceptions import JSONDecodeError
 
+from vellum.client import ApiError
 from vellum.client.types.vellum_secret import VellumSecret as ClientVellumSecret
 from vellum.workflows.constants import APIRequestMethod
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -83,9 +84,13 @@ class BaseAPINode(BaseNode, Generic[StateType]):
 
     def _vellum_execute_api(self, bearer_token, data, headers, method, url):
         client_vellum_secret = ClientVellumSecret(name=bearer_token.name) if bearer_token else None
-        vellum_response = self._context.vellum_client.execute_api(
-            url=url, method=method.value, body=data, headers=headers, bearer_token=client_vellum_secret
-        )
+        try:
+            vellum_response = self._context.vellum_client.execute_api(
+                url=url, method=method.value, body=data, headers=headers, bearer_token=client_vellum_secret
+            )
+        except ApiError as e:
+            NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.NODE_EXECUTION)
+
         return self.Outputs(
             json=vellum_response.json_,
             headers={header: value for header, value in vellum_response.headers.items()},

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -40,16 +40,14 @@ class BasePromptNode(BaseNode, Generic[StateType]):
         try:
             prompt_event_stream = self._get_prompt_event_stream()
         except ApiError as e:
-            if e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
-                raise NodeException(
-                    message=e.body.get("detail", "Failed to execute prompt"),
-                    code=WorkflowErrorCode.INVALID_INPUTS,
-                ) from e
+            self._handle_api_error(e)
 
-            raise NodeException(
-                message="Failed to execute prompt",
-                code=WorkflowErrorCode.INTERNAL_ERROR,
-            ) from e
+        # We don't use the INITIATED event anyway, so we can just skip it
+        # and use the exception handling to catch other api level errors
+        try:
+            next(prompt_event_stream)
+        except ApiError as e:
+            self._handle_api_error(e)
 
         outputs: Optional[List[PromptOutput]] = None
         for event in prompt_event_stream:
@@ -65,3 +63,15 @@ class BasePromptNode(BaseNode, Generic[StateType]):
                 raise NodeException.of(workflow_error)
 
         return outputs
+
+    def _handle_api_error(self, e: ApiError):
+        if e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
+            raise NodeException(
+                message=e.body.get("detail", "Failed to execute prompt"),
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            ) from e
+
+        raise NodeException(
+            message="Failed to execute prompt",
+            code=WorkflowErrorCode.INTERNAL_ERROR,
+        ) from e

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/ports/port.py

@@ -4,7 +4,10 @@ from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.edges.edge import Edge
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph, GraphTarget
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import ConditionType
@@ -82,11 +85,17 @@ class Port:
         return Port(condition_type=ConditionType.ELSE, fork_state=fork_state)
 
     def resolve_condition(self, state: BaseState) -> bool:
-        if self._condition is None:
-            return False
-
-        value = self._condition.resolve(state)
-        return bool(value)
+        try:
+            if self._condition is None:
+                return False
+
+            value = self._condition.resolve(state)
+            return bool(value)
+        except InvalidExpressionException as e:
+            raise NodeException(
+                message=f"Failed to resolve condition for port `{self.name}`: {e}",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            ) from e
 
     def serialize(self) -> dict:
         return {

{vellum_ai-0.13.27 → vellum_ai-0.13.28}/src/vellum/workflows/utils/vellum_variables.py

@@ -45,6 +45,9 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
             ]
             if types == actual_types_with_explicit_ref:
                 return "JSON"
+            # Number now supports float and int
+            elif types == [float, int]:
+                return "NUMBER"
             raise ValueError(f"Expected Descriptor to only have one type, got {types}")
 
         type_ = type_.types[0]