vellum-ai 0.14.53__tar.gz → 0.14.54__tar.gz

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/PKG-INFO

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

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/ee/vellum_cli/logger.py

@@ -1,5 +1,6 @@
 import logging
 import os
+from typing import Optional
 
 
 class CLIFormatter(logging.Formatter):
@@ -34,3 +35,14 @@ def load_cli_logger() -> logging.Logger:
     logger.addHandler(handler)
 
     return logger
+
+
+def handle_cli_error(logger: logging.Logger, title: str, message: str, suggestion: Optional[str] = None):
+    logger.error("\n\033[1;31m✖ {}\033[0m".format(title))  # Bold red X and title
+    logger.error("\n\033[1m{}\033[0m".format(message))  # Bold message
+    if suggestion:
+        logger.error("\n\033[1;34mNext steps:\033[0m")  # Bold blue
+        logger.error(suggestion)
+
+    logger.error(f"{title}: {message}")
+    exit(1)

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/ee/vellum_cli/push.py

@@ -15,7 +15,7 @@ from vellum.types import WorkflowPushDeploymentConfigRequest
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_cli.config import DEFAULT_WORKSPACE_CONFIG, WorkflowConfig, WorkflowDeploymentConfig, load_vellum_cli_config
-from vellum_cli.logger import load_cli_logger
+from vellum_cli.logger import handle_cli_error, load_cli_logger
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 
@@ -178,41 +178,39 @@ def push_command(
             strict=strict,
         )
     except ApiError as e:
-        if e.status_code != 400 or not isinstance(e.body, dict) or "diffs" not in e.body:
-            raise e
-
-        diffs: dict = e.body["diffs"]
-        generated_only = diffs.get("generated_only", [])
-        generated_only_str = (
-            "\n".join(
-                ["Files that were generated but not found in the original project:"]
-                + [f"- {file}" for file in generated_only]
+        if e.status_code == 400 and isinstance(e.body, dict) and "diffs" in e.body:
+            diffs: dict = e.body["diffs"]
+            generated_only = diffs.get("generated_only", [])
+            generated_only_str = (
+                "\n".join(
+                    ["Files that were generated but not found in the original project:"]
+                    + [f"- {file}" for file in generated_only]
+                )
+                if generated_only
+                else ""
             )
-            if generated_only
-            else ""
-        )
 
-        original_only = diffs.get("original_only", [])
-        original_only_str = (
-            "\n".join(
-                ["Files that were found in the original project but not generated:"]
-                + [f"- {file}" for file in original_only]
+            original_only = diffs.get("original_only", [])
+            original_only_str = (
+                "\n".join(
+                    ["Files that were found in the original project but not generated:"]
+                    + [f"- {file}" for file in original_only]
+                )
+                if original_only
+                else ""
             )
-            if original_only
-            else ""
-        )
 
-        modified = diffs.get("modified", {})
-        modified_str = (
-            "\n\n".join(
-                ["Files that were different between the original project and the generated artifact:"]
-                + ["\n".join(line.strip() for line in lines) for lines in modified.values()]
+            modified = diffs.get("modified", {})
+            modified_str = (
+                "\n\n".join(
+                    ["Files that were different between the original project and the generated artifact:"]
+                    + ["\n".join(line.strip() for line in lines) for lines in modified.values()]
+                )
+                if modified
+                else ""
             )
-            if modified
-            else ""
-        )
 
-        reported_diffs = f"""\
+            reported_diffs = f"""\
 {e.body.get("detail")}
 
 {generated_only_str}
@@ -221,8 +219,14 @@ def push_command(
 
 {modified_str}
 """
-        logger.error(reported_diffs)
-        return
+            logger.error(reported_diffs)
+            return
+
+        if e.status_code == 400 and isinstance(e.body, dict) and "detail" in e.body:
+            handle_cli_error(logger, title="API request to /workflows/push failed.", message=e.body["detail"])
+            return
+
+        raise e
 
     if dry_run:
         error_messages = [str(e) for e in workflow_display.errors]

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/ee/vellum_cli/tests/test_push.py

@@ -525,6 +525,37 @@ Files that were different between the original project and the generated artifac
     )
 
 
+def test_push__push_fails_due_to_400_error(mock_module, vellum_client):
+    # GIVEN a single workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+
+    # AND a workflow exists in the module successfully
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns a 4xx response
+    vellum_client.workflows.push.side_effect = ApiError(
+        status_code=400,
+        body={
+            "detail": "Pushing the Workflow failed because you did something wrong",
+        },
+    )
+
+    # WHEN calling `vellum push` on strict mode
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module])
+
+    # THEN it should fail with a user error code
+    assert result.exit_code == 1
+
+    # AND the error message should be in the error message
+    assert "API request to /workflows/push failed." in result.output
+    assert "Pushing the Workflow failed because you did something wrong" in result.output
+
+    # AND the stack trace should not be
+    assert "Traceback" not in result.output
+
+
 @pytest.mark.parametrize(
     "file_data",
     [

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -583,14 +583,30 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         # DEPRECATED: This will be removed in the 0.15.0 release
         workflow_class: Optional[Type[BaseWorkflow]] = None,
     ) -> Union[WorkflowEventDisplayContext, None]:
-        workflow_display_module = f"{module_path}.display.workflow"
+        full_workflow_display_module_path = f"{module_path}.display.workflow"
         try:
-            display_class = importlib.import_module(workflow_display_module)
+            display_module = importlib.import_module(full_workflow_display_module_path)
         except ModuleNotFoundError:
+            logger.exception("Failed to import workflow display module: %s", full_workflow_display_module_path)
             return None
 
-        WorkflowDisplayClass = display_class.WorkflowDisplay
-        if not isinstance(WorkflowDisplayClass, type) or not issubclass(WorkflowDisplayClass, BaseWorkflowDisplay):
+        WorkflowDisplayClass: Optional[Type[BaseWorkflowDisplay]] = None
+        for name, definition in display_module.__dict__.items():
+            if name.startswith("_"):
+                continue
+
+            if (
+                not isinstance(definition, type)
+                or not issubclass(definition, BaseWorkflowDisplay)
+                or definition == BaseWorkflowDisplay
+            ):
+                continue
+
+            WorkflowDisplayClass = definition
+            break
+
+        if not WorkflowDisplayClass:
+            logger.exception("No workflow display class found in module: %s", full_workflow_display_module_path)
             return None
 
         return WorkflowDisplayClass().get_event_display_context()

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/ee/vellum_ee/workflows/tests/test_display_meta.py

@@ -54,3 +54,51 @@ def test_base_class_dynamic_import(files):
     }
     assert display_meta
     assert display_meta.model_dump(mode="json") == expected_result
+
+
+def test_gather_event_display_context__custom_workflow_name():
+    # GIVEN a workflow module with a custom workflow name
+    workflow_output_id = uuid4()
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+
+class MyCustomWorkflow(BaseWorkflow):
+    class Outputs(BaseWorkflow.Outputs):
+        answer = "foo"
+""",
+        "display/__init__.py": """\
+# flake8: noqa: F401, F403
+
+from .workflow import *
+""",
+        "display/workflow.py": f"""\
+from uuid import UUID
+from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
+from vellum_ee.workflows.display.base import WorkflowOutputDisplay
+from ..workflow import MyCustomWorkflow
+
+class MyCustomWorkflowDisplay(BaseWorkflowDisplay[MyCustomWorkflow]):
+    output_displays = {{
+        MyCustomWorkflow.Outputs.answer: WorkflowOutputDisplay(
+            id=UUID("{workflow_output_id}"), name="answer"
+        )
+    }}
+""",
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    # WHEN the workflow display context is gathered
+    Workflow = BaseWorkflow.load_from_module(namespace)
+    display_meta = BaseWorkflowDisplay.gather_event_display_context(namespace, Workflow)
+
+    # THEN the workflow display context is successfully gathered
+    assert display_meta
+    assert display_meta.workflow_outputs == {
+        "answer": workflow_output_id,
+    }

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/pyproject.toml

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

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/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.14.53",
+            "X-Fern-SDK-Version": "0.14.54",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/src/vellum/workflows/nodes/bases/base.py

@@ -2,12 +2,13 @@ from dataclasses import field
 from functools import cached_property, reduce
 import inspect
 from types import MappingProxyType
-from uuid import UUID
+from uuid import UUID, uuid4
 from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union, cast, get_args
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
+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
@@ -325,6 +326,36 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
+        @classmethod
+        def _queue_node_execution(
+            cls, state: StateType, dependencies: Set["Type[BaseNode]"], invoked_by: Optional[Edge] = None
+        ) -> UUID:
+            """
+            Queues a future execution of a node, returning the span id of the execution.
+
+            We may combine this into the should_initiate method, but we'll keep it separate for now to avoid
+            breaking changes until the 0.15.0 release.
+            """
+
+            execution_id = uuid4()
+            if not invoked_by:
+                return execution_id
+
+            if cls.merge_behavior not in {MergeBehavior.AWAIT_ANY, MergeBehavior.AWAIT_ALL}:
+                return execution_id
+
+            source_node = invoked_by.from_port.node_class
+            for queued_node_execution_id in state.meta.node_execution_cache._node_executions_queued[cls.node_class]:
+                if source_node not in state.meta.node_execution_cache._dependencies_invoked[queued_node_execution_id]:
+                    state.meta.node_execution_cache._invoke_dependency(
+                        queued_node_execution_id, cls.node_class, source_node, dependencies
+                    )
+                    return queued_node_execution_id
+
+            state.meta.node_execution_cache._node_executions_queued[cls.node_class].append(execution_id)
+            state.meta.node_execution_cache._invoke_dependency(execution_id, cls.node_class, source_node, dependencies)
+            return execution_id
+
     class Execution(metaclass=_BaseNodeExecutionMeta):
         node_class: Type["BaseNode"]
         count: int

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/src/vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -11,7 +11,7 @@ from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePro
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
-from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 
 
 class FunctionNode(BaseNode):
@@ -21,6 +21,9 @@ class FunctionNode(BaseNode):
 
 
 class ToolRouterNode(InlinePromptNode):
+    class Trigger(InlinePromptNode.Trigger):
+        merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES
+
     def run(self) -> Iterator[BaseOutput]:
         self.prompt_inputs = {**self.prompt_inputs, "chat_history": self.state.chat_history}  # type: ignore
         generator = super().run()

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/src/vellum/workflows/runner/runner.py

@@ -431,7 +431,7 @@ class WorkflowRunner(Generic[StateType]):
                     return
 
             all_deps = self._dependencies[node_class]
-            node_span_id = state.meta.node_execution_cache.queue_node_execution(node_class, all_deps, invoked_by)
+            node_span_id = node_class.Trigger._queue_node_execution(state, all_deps, invoked_by)
             if not node_class.Trigger.should_initiate(state, all_deps, node_span_id):
                 return
 

{vellum_ai-0.14.53 → vellum_ai-0.14.54}/src/vellum/workflows/state/base.py

@@ -16,7 +16,6 @@ from pydantic_core import core_schema
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.constants import undefined
-from vellum.workflows.edges.edge import Edge
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.references import ExternalInputReference, OutputReference, StateValueReference
 from vellum.workflows.types.definition import CodeResourceDefinition, serialize_type_encoder_with_id
@@ -174,23 +173,6 @@ class NodeExecutionCache:
         if all(dep in self._dependencies_invoked[execution_id] for dep in dependencies):
             self._node_executions_queued[node].remove(execution_id)
 
-    def queue_node_execution(
-        self, node: Type["BaseNode"], dependencies: Set["Type[BaseNode]"], invoked_by: Optional[Edge] = None
-    ) -> UUID:
-        execution_id = uuid4()
-        if not invoked_by:
-            return execution_id
-
-        source_node = invoked_by.from_port.node_class
-        for queued_node_execution_id in self._node_executions_queued[node]:
-            if source_node not in self._dependencies_invoked[queued_node_execution_id]:
-                self._invoke_dependency(queued_node_execution_id, node, source_node, dependencies)
-                return queued_node_execution_id
-
-        self._node_executions_queued[node].append(execution_id)
-        self._invoke_dependency(execution_id, node, source_node, dependencies)
-        return execution_id
-
     def is_node_execution_initiated(self, node: Type["BaseNode"], execution_id: UUID) -> bool:
         return execution_id in self._node_executions_initiated[node]