vellum-ai 0.13.27__py3-none-any.whl → 0.13.28__py3-none-any.whl

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/workflows/descriptors/exceptions.py

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

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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]

{vellum_ai-0.13.27.dist-info → vellum_ai-0.13.28.dist-info}/METADATA

@@ -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.dist-info → vellum_ai-0.13.28.dist-info}/RECORD

@@ -7,14 +7,14 @@ vellum_cli/image_push.py,sha256=SJwhwWJsLjwGNezNVd_oCVpFMfPsAB3dfLWmriZZUtw,4419
 vellum_cli/logger.py,sha256=PuRFa0WCh4sAGFS5aqWB0QIYpS6nBWwPJrIXpWxugV4,1022
 vellum_cli/ping.py,sha256=lWyJw6sziXjyTopTYRdFF5hV-sYPVDdX0yVbG5fzcY4,585
 vellum_cli/pull.py,sha256=7yvg4oBOgsbBEsgXtCpYlNR4AOR8hPICamY-4HI-3kM,9031
-vellum_cli/push.py,sha256=j4XLSircGX3aHz35i3HyJ4jynWiEH6xVm1uspavPeLM,9101
+vellum_cli/push.py,sha256=xjTNbLwOVFNU3kpBrm56Bk5QkSRrJ9z86qceghCzfIA,9655
 vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_cli/tests/conftest.py,sha256=AFYZryKA2qnUuCPBxBKmHLFoPiE0WhBFFej9tNwSHdc,1526
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
 vellum_cli/tests/test_ping.py,sha256=QtbhYKMYn1DFnDyBij2mkQO32j9KOpZ5Pf0yek7k_Ao,1284
 vellum_cli/tests/test_pull.py,sha256=JURmgGs5lSnpzefSx4K13eF2swv7O8OF86-4df81Zjo,25241
-vellum_cli/tests/test_push.py,sha256=e0nJlyRQjfRPjXlHm9uh5Z5eGZMzu1lnpEhO35nGlsc,21330
+vellum_cli/tests/test_push.py,sha256=zDZfSQCHCdKqSfGVHGRgX9VPm-H7EW5gwMf55dm_PFg,23438
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -116,7 +116,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=j6zi0NZ4BMC6JrwckvzMWuG5x8KoOvO4KqsLhvVCa68,117624
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=ov-BIscDOkAsVlrwx5oFTC_b2ka0l1D__GsoKPKFG5w,1869
+vellum/client/core/client_wrapper.py,sha256=K05OPis1DlTJSg2W24og49fZhiG0aW5aExROjEOtIAA,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -1269,6 +1269,7 @@ vellum/workflows/constants.py,sha256=Z0W4YlqfSlSgWC11PrVUPs6ZOBeIaQ78E_90J1hohiw
 vellum/workflows/context.py,sha256=R8qdsFbD_0p7B6PWnyvSrZ_aOgMtGw-_uk0P0UAmwLA,1230
 vellum/workflows/descriptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/descriptors/base.py,sha256=gSib3vJpcI_UC8y8jhdp-hOK3_TGTF-SuwdhxF6x5iQ,14332
+vellum/workflows/descriptors/exceptions.py,sha256=gUy4UD9JFUKSeQnQpeuDSLiRqWjWiIsxLahB7p_q3JY,54
 vellum/workflows/descriptors/tests/test_utils.py,sha256=63w1P6PELNhWzpg1BqL8y2XQZ8XRt0RUkHgLcsXyOQE,4592
 vellum/workflows/descriptors/utils.py,sha256=nE51MR0KMy3SVHPBg0wjJ3CSJBTLM3tZnVUC_enQEIw,3826
 vellum/workflows/edges/__init__.py,sha256=wSkmAnz9xyi4vZwtDbKxwlplt2skD7n3NsxkvR_pUus,50
@@ -1287,33 +1288,33 @@ vellum/workflows/events/types.py,sha256=cjRE8WL8tYCFradd9NOGl_H0mN3LiWWnA1uHmyT2
 vellum/workflows/events/workflow.py,sha256=lveoWXtVRLjdO_nu0z6VlKeTqlGimogamiFR-jYihlE,5184
 vellum/workflows/exceptions.py,sha256=l-FLGvXywxg6ivolCts71b8pcsYAWoB1cmUR4Jx7N8g,614
 vellum/workflows/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/expressions/accessor.py,sha256=daIkEudAdyiqCOzO9x_3cy-Y9ilYgNWSEeqcFelkjI0,1743
+vellum/workflows/expressions/accessor.py,sha256=ItZF7fMLzVTqsdAiaXb5SiDupXmX0X9xbIus1W6hRds,1870
 vellum/workflows/expressions/and_.py,sha256=I7lNqrUM3-m_5hmjjiMhaHhJtKcLj39kEFVWPDOqwfo,916
-vellum/workflows/expressions/begins_with.py,sha256=Ae-RBz_0Xr1WiX1EP0mSgCOOUo-ji1A85aAGd-4BscY,1012
-vellum/workflows/expressions/between.py,sha256=xjc_-TLDN-25tVQ9k9aZciH0wOfqrXV8qNmyGOhimd8,1365
+vellum/workflows/expressions/begins_with.py,sha256=FnWsQXbENm0ZwkfEP7dR8Qx4_MMrzj6C1yqAV2KaNHw,1123
+vellum/workflows/expressions/between.py,sha256=dVeddT6YA91eOAlE1Utg7C7gnCiYE7WP-dg17yXUeAY,1492
 vellum/workflows/expressions/coalesce_expression.py,sha256=Fyx2cvi715hPhi2OEfH3D0gD_smQIa2aDwnjr7q2Ngs,1186
-vellum/workflows/expressions/contains.py,sha256=j8iKPxytSC0Ig0e-Ie_1vTZ9kFG-4mS1SZ4L0fUP3K4,1045
-vellum/workflows/expressions/does_not_begin_with.py,sha256=CERIru9CGJWGXWmT5QyVC7wbZBJiZu3qNR-cyrJzzec,1026
-vellum/workflows/expressions/does_not_contain.py,sha256=Z7_v_j9VlUFiZo8nFfqaSj7eAYy7EHiIILceS8F2ioE,1067
-vellum/workflows/expressions/does_not_end_with.py,sha256=WB34F0mEtCtKBQ0hliNVj56vdD_ucWxgjyJSH-pKMkI,1020
+vellum/workflows/expressions/contains.py,sha256=gYpQQlsY8YxBWfisfCI4I_mc-IW7f6U4ZTpuN3WZtMA,1313
+vellum/workflows/expressions/does_not_begin_with.py,sha256=qcnIJsxg4Jt82i2L-PW6ZhKP3C-OlEiXbiIgwHQc5RE,1137
+vellum/workflows/expressions/does_not_contain.py,sha256=B4m23jJiKBM6ANVtA4WfdUnT-MdQGxVVgR14ypgYBIs,1195
+vellum/workflows/expressions/does_not_end_with.py,sha256=idw2OSuIk02XwBM5CXYOESf655mRrdBREjeinZ5tmVQ,1131
 vellum/workflows/expressions/does_not_equal.py,sha256=LNiCibRZZIxaIrwotjW3SIsKYHWR7BpOItFI-x5KuKU,764
-vellum/workflows/expressions/ends_with.py,sha256=qrnCOfBl-66Hgdz0d_EEej_Md9EMzIYP9NeZBpIP3y0,1006
+vellum/workflows/expressions/ends_with.py,sha256=FkWZjAudc_DFM-fK-A3_tr6WXavfs_Qi7F6JtVgMglw,1117
 vellum/workflows/expressions/equals.py,sha256=gbI6BKQR7cLQih226-ge_BFSLprgEjqbdiIxo7WFg_E,758
-vellum/workflows/expressions/greater_than.py,sha256=nMi6iAo0vi2hM3JeKfQSCy7DnXbdoyueGEZpGCRImH8,1152
-vellum/workflows/expressions/greater_than_or_equal_to.py,sha256=xUDjfsOrJdoWm9K7OafGDGsuyvYS3xbMjyV4umvA50Q,1164
-vellum/workflows/expressions/in_.py,sha256=tdDTvePdG4WyRkwmSaA4hsUdFJNiIMlrEG6oRrUskjI,1028
-vellum/workflows/expressions/is_blank.py,sha256=u8mGreoZb5t_q2mhhmpD7ytAfFCFUAW9APsDapqUsDY,809
+vellum/workflows/expressions/greater_than.py,sha256=fTM2YF3FY_eOkRtGpgVWcv8qNt4K3lazONUIqcD8oe8,1263
+vellum/workflows/expressions/greater_than_or_equal_to.py,sha256=sazL_-Jsgjo4jcQeE-6EC0BFHZACriaYMQH4rn0dqEo,1275
+vellum/workflows/expressions/in_.py,sha256=RgiAIFntXGN4eWoOVBj1gqLymnBxSiw5hYD3TngF3dk,1123
+vellum/workflows/expressions/is_blank.py,sha256=vOOmK5poXmiNRVH7MR0feIFnL4rwKn7vmmTkJ9TcfVU,904
 vellum/workflows/expressions/is_nil.py,sha256=dtgY9Czm3slk45weARspwtfhQmVh0BIUsPOECrATLrA,740
-vellum/workflows/expressions/is_not_blank.py,sha256=npXK9KSUm0nWeT6WJ5LLKB3owgBXHr7SpH8j4W0WapI,816
+vellum/workflows/expressions/is_not_blank.py,sha256=GJNTe8TKIbh4RwWPFuPwEQw0hbxg2MobHg8bcal4xWU,911
 vellum/workflows/expressions/is_not_nil.py,sha256=M5Qhtp_H07PORjFN2WapwA1Njp_KaANmLWbfckSSscM,761
 vellum/workflows/expressions/is_not_null.py,sha256=EoHXFgZScKP_BM2a5Z7YFQN6l7RMEtzs5x5nlvaSST8,671
 vellum/workflows/expressions/is_not_undefined.py,sha256=8NGwA0wZP_aHRy5qJOtaNhRCJyXKekwBNJalSk6Rdmo,727
 vellum/workflows/expressions/is_null.py,sha256=C75ALGlG_sTGcxI46tm9HtgPVfJ7DwTIyKzX8qtEiDU,660
 vellum/workflows/expressions/is_undefined.py,sha256=c9Oc1fdp911fQQ8WMG2L-TeUSqz1wF8cOTuLutJKbe8,716
-vellum/workflows/expressions/less_than.py,sha256=DTWjbhaegnsCWnFSLNldTQr94Dqg3rqWOgMWI7IVsII,1149
-vellum/workflows/expressions/less_than_or_equal_to.py,sha256=IxP1VeXAzXrccdIWT2hm6Fj3Sr-7rPW-DKOHl6MrHjo,1161
-vellum/workflows/expressions/not_between.py,sha256=H2huRR95D9Qb7lCHmK7BcK-Ug-E1gA3sMWz9PGcAVZs,1379
-vellum/workflows/expressions/not_in.py,sha256=OQkN5G1E6VoTDpoLvx7X3GbohLlqEAYHV0rVVUV7ow4,1049
+vellum/workflows/expressions/less_than.py,sha256=BcfkUH6Bb2inwR8jILn1hebUiyC74foVijBA-JymwT0,1260
+vellum/workflows/expressions/less_than_or_equal_to.py,sha256=4i1FR6FzlKam29cZPPnXUqACslO242Ww-wZZY4CEK6A,1272
+vellum/workflows/expressions/not_between.py,sha256=ZtRJeJDSSlOvajL8YoBoh5o_khjIn9xSSeQCnXYbHFE,1506
+vellum/workflows/expressions/not_in.py,sha256=pFvwkFPsn3WJw61ssFgM2U1dqWEeglfz4FVT4xwm5Mc,1144
 vellum/workflows/expressions/or_.py,sha256=s-8YdMSSCDS2yijR38kguwok3iqmDMMgDYKV93b4O4s,914
 vellum/workflows/graph/__init__.py,sha256=3sHlay5d_-uD7j3QJXiGl0WHFZZ_QScRvgyDhN2GhHY,74
 vellum/workflows/graph/graph.py,sha256=GGR8cGpSuNWPIiTWNWsj6l70upb5nIxAyFcn7VdaJIs,5506
@@ -1324,7 +1325,7 @@ vellum/workflows/inputs/base.py,sha256=1kMgr0WqCYdWUqgFvgSoAMw2067FAlgwhGXLgbIOr
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
-vellum/workflows/nodes/bases/base.py,sha256=v6Y38xRTTKQxfvDpnx7X37EQN6Mrxu2vKtMDQiR2g8A,14186
+vellum/workflows/nodes/bases/base.py,sha256=jKgneygDa47BkuApl8VgvYItT3DMFuaqO3RetJwqPdg,14116
 vellum/workflows/nodes/bases/base_adornment_node.py,sha256=eFTgsPCYb3eyGS0-kw7C6crFnwFx437R5wh9-8bWYts,2905
 vellum/workflows/nodes/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=51CueFVty9XYASC0rKr1cXWejho5WElmhfhp6cCONy0,3811
@@ -1357,9 +1358,9 @@ vellum/workflows/nodes/displayable/api_node/tests/__init__.py,sha256=47DEQpj8HBS
 vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=yo3zTMRxgpSdWmJ68X610A5rrtCchyfqhcDd2X-GJiU,1249
 vellum/workflows/nodes/displayable/bases/__init__.py,sha256=0mWIx3qUrzllV7jqt7wN03vWGMuI1WrrLZeMLT2Cl2c,304
 vellum/workflows/nodes/displayable/bases/api_node/__init__.py,sha256=1jwx4WC358CLA1jgzl_UD-rZmdMm2v9Mps39ndwCD7U,64
-vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=nIFkP7eeXXSzOVUoQgjPPCzy3_P083X_F5fCm2OAjdU,3798
+vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=TeVsAhUPEx_lbiyhGcWarqBKZeJJZAJx8mwym9qhwVs,3994
 vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org3xTvgp1pA0uUXFfnJr29D3HzCey2lEdYF4zbIUgo,70
-vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=r_gOmeGFQQfzhAc1_bmzcwUvH-Xllc93gE7miTV4rQE,2824
+vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=cKsNziwWJ9jUjS578I5dIka-zmsXz94hYZR3Cofm8aE,3140
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py,sha256=Hl35IAoepRpE-j4cALaXVJIYTYOF3qszyVbxTj4kS1s,82
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/constants.py,sha256=fnjiRWLoRlC4Puo5oQcpZD5Hd-EesxsAo9l5tGAkpZQ,270
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=UrmI8NkNJFGq9f59gD12S1e8D_R3ROHc934JmtfQk9I,6841
@@ -1416,7 +1417,7 @@ vellum/workflows/outputs/__init__.py,sha256=AyZ4pRh_ACQIGvkf0byJO46EDnSix1ZCAXfv
 vellum/workflows/outputs/base.py,sha256=Wu48tqyQoxpflBUcwzKeZjSVp1LPKrBwuIvnx__9H90,8459
 vellum/workflows/ports/__init__.py,sha256=bZuMt-R7z5bKwpu4uPW7LlJeePOQWmCcDSXe5frUY5g,101
 vellum/workflows/ports/node_ports.py,sha256=g4A-8iUAvEJSkaWppbvzAR8XU02R9U-qLN4rP2Kq4Aw,2743
-vellum/workflows/ports/port.py,sha256=rc3GB7dDQCUs0IbY08a92-31YzJHQgBeww13brSJ2Js,3172
+vellum/workflows/ports/port.py,sha256=eI2SOZPZ5rsC3jMsxW6Rbn0NpaYQsrR7AapiIbbiy8Q,3635
 vellum/workflows/ports/utils.py,sha256=pEjVNJKw9LhD_cFN-o0MWBOW2ejno7jv26qqzjLxwS4,1662
 vellum/workflows/references/__init__.py,sha256=glHFC1VfXmcbNvH5VzFbkT03d8_D7MMcvEcsUBrzLIs,591
 vellum/workflows/references/constant.py,sha256=6yUT4q1sMj1hkI_tzzQ9AYcmeeDYFUNCqUq_W2DN0S8,540
@@ -1460,13 +1461,13 @@ vellum/workflows/utils/tests/test_names.py,sha256=aOqpyvMsOEK_9mg_-yaNxQDW7QQfwq
 vellum/workflows/utils/tests/test_uuids.py,sha256=i77ABQ0M3S-aFLzDXHJq_yr5FPkJEWCMBn1HJ3DObrE,437
 vellum/workflows/utils/tests/test_vellum_variables.py,sha256=6H-BpmbIEmVRO75QQ3Rfy4bEUMMP2qwGzx2Gp1uXbfw,879
 vellum/workflows/utils/uuids.py,sha256=DFzPv9RCvsKhvdTEIQyfSek2A31D6S_QcmeLPbgrgTY,739
-vellum/workflows/utils/vellum_variables.py,sha256=g5xHYB8etfHE32ek19nP6Anf8NyjhmUtOwO2KmQ5xZU,3111
+vellum/workflows/utils/vellum_variables.py,sha256=fC2aSLvlS31D15dOWu43LBRR0QsgUKNXBiCUvvaLXSs,3231
 vellum/workflows/vellum_client.py,sha256=ODrq_TSl-drX2aezXegf7pizpWDVJuTXH-j6528t75s,683
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
 vellum/workflows/workflows/base.py,sha256=uYT0TQnEDtVaH3pErq785FhxxEEmk7C5ZGfuSO3QK8c,18537
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
-vellum_ai-0.13.27.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.13.27.dist-info/METADATA,sha256=vsSAQXzNF0pgVlHW2s8G6S4tfzSjLEOplZ9JR0BIR9I,5335
-vellum_ai-0.13.27.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.13.27.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.13.27.dist-info/RECORD,,
+vellum_ai-0.13.28.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.13.28.dist-info/METADATA,sha256=wrTghMo3kpO_xtsK1SbioWmx3p_ZdG0vifuj57JrZvs,5408
+vellum_ai-0.13.28.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.13.28.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.13.28.dist-info/RECORD,,

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_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"