vellum-ai 1.1.2__tar.gz → 1.1.3__tar.gz

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/PKG-INFO

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

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/ee/vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -42,7 +42,7 @@ class BaseCodeExecutionNodeDisplay(BaseNodeDisplay[_CodeExecutionNodeType], Gene
                 script_filepath=filepath,
             )
             if not file_code:
-                raise NodeValidationError(f"Filepath '{filepath}' does not exist", node.__name__)
+                display_context.add_error(NodeValidationError(f"Filepath '{filepath}' does not exist", node.__name__))
             code_value = file_code
         else:
             code_value = ""

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py

@@ -197,7 +197,61 @@ def test_serialize_node__with_non_exist_code_input_path_with_dry_run():
                     "display_data": {"position": {"x": 0.0, "y": -50.0}},
                     "base": None,
                     "definition": None,
-                }
+                },
+                {
+                    "id": "ac90c0ce-f393-438c-a24f-e5e9a9286182",
+                    "type": "CODE_EXECUTION",
+                    "inputs": [
+                        {
+                            "id": "a0b9d6f6-ce59-4075-8db6-866781bc73ef",
+                            "key": "code",
+                            "value": {
+                                "rules": [{"type": "CONSTANT_VALUE", "data": {"type": "JSON", "value": None}}],
+                                "combinator": "OR",
+                            },
+                        },
+                        {
+                            "id": "58598cc8-aa8a-4b4f-99fb-09f6815b6c01",
+                            "key": "runtime",
+                            "value": {
+                                "rules": [
+                                    {"type": "CONSTANT_VALUE", "data": {"type": "STRING", "value": "PYTHON_3_11_6"}}
+                                ],
+                                "combinator": "OR",
+                            },
+                        },
+                    ],
+                    "data": {
+                        "label": "My Node",
+                        "error_output_id": None,
+                        "source_handle_id": "7afa3858-f50c-4116-936a-a401e3b2c60f",
+                        "target_handle_id": "3a39ea63-9f86-4891-a902-0216a7190720",
+                        "code_input_id": "a0b9d6f6-ce59-4075-8db6-866781bc73ef",
+                        "runtime_input_id": "58598cc8-aa8a-4b4f-99fb-09f6815b6c01",
+                        "output_type": "STRING",
+                        "packages": [],
+                        "output_id": "00b2120e-b642-46e4-8276-5f3c69d8a6cb",
+                        "log_output_id": "47e3eeca-4bf8-492e-b8ac-28c7d389c886",
+                    },
+                    "display_data": {"position": {"x": 200.0, "y": -50.0}},
+                    "base": {
+                        "name": "CodeExecutionNode",
+                        "module": ["vellum", "workflows", "nodes", "displayable", "code_execution_node", "node"],
+                    },
+                    "definition": {
+                        "name": "MyNode",
+                        "module": [
+                            "vellum_ee",
+                            "workflows",
+                            "display",
+                            "nodes",
+                            "vellum",
+                            "tests",
+                            "test_code_execution_node",
+                        ],
+                    },
+                    "ports": [{"id": "7afa3858-f50c-4116-936a-a401e3b2c60f", "name": "default", "type": "DEFAULT"}],
+                },
             ],
             "edges": [
                 {

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_tool_calling_node.py

@@ -161,57 +161,20 @@ def test_serialize_node__tool_calling_node__mcp_server_api_key():
         "id": "6c0f7d4f-3c8a-4201-b588-8398d3c97480",
         "name": "functions",
         "value": {
-            "type": "ARRAY_REFERENCE",
-            "items": [
-                {
-                    "type": "DICTIONARY_REFERENCE",
-                    "entries": [
-                        {
-                            "id": "bcf2713b-19fc-4b4b-8ff5-b45c8e63c665",
-                            "key": "type",
-                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "MCP_SERVER"}},
-                        },
-                        {
-                            "id": "4e00439e-ce6f-4e0a-be4c-0fc05990ec44",
-                            "key": "name",
-                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "my-mcp-server"}},
-                        },
-                        {
-                            "id": "9a3dcca9-4595-4efb-ada6-c011721f7018",
-                            "key": "url",
-                            "value": {
-                                "type": "CONSTANT_VALUE",
-                                "value": {"type": "STRING", "value": "https://my-mcp-server.com"},
-                            },
-                        },
-                        {
-                            "id": "21c3a6ce-7607-42a4-92b8-9d7c4061edce",
-                            "key": "authorization_type",
-                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "API_KEY"}},
-                        },
-                        {
-                            "id": "dcf8e8f0-84d2-4ffb-b0e6-218c569015a4",
-                            "key": "bearer_token_value",
-                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
-                        },
-                        {
-                            "id": "fe93f516-42c0-40cf-b476-50bd04857d5f",
-                            "key": "api_key_header_key",
-                            "value": {
-                                "type": "CONSTANT_VALUE",
-                                "value": {"type": "STRING", "value": "my-api-key-header-key"},
-                            },
-                        },
-                        {
-                            "id": "750ed8ca-3bf3-46be-96f0-2c92d19d2084",
-                            "key": "api_key_header_value",
-                            "value": {
-                                "type": "ENVIRONMENT_VARIABLE",
-                                "environment_variable": "my-api-key-header-value",
-                            },
-                        },
-                    ],
-                }
-            ],
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "MCP_SERVER",
+                        "name": "my-mcp-server",
+                        "url": "https://my-mcp-server.com",
+                        "authorization_type": "API_KEY",
+                        "bearer_token_value": None,
+                        "api_key_header_key": "my-api-key-header-key",
+                        "api_key_header_value": "my-api-key-header-value",
+                    }
+                ],
+            },
         },
     }

vellum_ai-1.1.3/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_mcp_serialization.py

@@ -0,0 +1,64 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_mcp_tool.workflow import BasicToolCallingNodeMCPWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a generic node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeMCPWorkflow)
+
+    serialized_workflow: dict = workflow_display.serialize()
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    assert not DeepDiff(
+        [
+            {"id": "3934525a-4807-4dd3-a44f-8569033fece1", "key": "text", "type": "STRING"},
+            {"id": "a6ba35f0-306b-45a4-ad79-c1e9b9a5515c", "key": "chat_history", "type": "CHAT_HISTORY"},
+        ],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+    function_attributes = next(
+        (attribute for attribute in tool_calling_node["attributes"] if attribute["name"] == "functions"),
+    )
+    assert function_attributes == {
+        "id": "20adf593-c4f0-4c67-8e36-37eb66f28f66",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "MCP_SERVER",
+                        "name": "github",
+                        "url": "https://api.githubcopilot.com/mcp/",
+                        "authorization_type": "BEARER_TOKEN",
+                        "bearer_token_value": "GITHUB_PERSONAL_ACCESS_TOKEN",
+                        "api_key_header_key": None,
+                        "api_key_header_value": None,
+                    }
+                ],
+            },
+        },
+    }

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/ee/vellum_ee/workflows/display/types.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, Tuple, Type
+from typing import TYPE_CHECKING, Dict, Iterator, List, Tuple, Type
 
 from vellum.client import Vellum as VellumClient
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -51,3 +51,16 @@ class WorkflowDisplayContext:
     workflow_output_displays: WorkflowOutputDisplays = field(default_factory=dict)
     edge_displays: EdgeDisplays = field(default_factory=dict)
     port_displays: PortDisplays = field(default_factory=dict)
+    _errors: List[Exception] = field(default_factory=list)
+    _dry_run: bool = False
+
+    def add_error(self, error: Exception) -> None:
+        if self._dry_run:
+            self._errors.append(error)
+            return
+
+        raise error
+
+    @property
+    def errors(self) -> Iterator[Exception]:
+        return iter(self._errors)

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -266,10 +266,19 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         }
 
     if isinstance(value, EnvironmentVariableReference):
-        return {
-            "type": "ENVIRONMENT_VARIABLE",
-            "environment_variable": value.name,
-        }
+        if value.serialize_as_constant:
+            return {
+                "type": "CONSTANT_VALUE",
+                "value": {
+                    "type": "STRING",
+                    "value": value.name,
+                },
+            }
+        else:
+            return {
+                "type": "ENVIRONMENT_VARIABLE",
+                "environment_variable": value.name,
+            }
 
     if isinstance(value, ExecutionCountReference):
         node_class_display = display_context.global_node_displays[value.node_class]

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -6,7 +6,7 @@ import inspect
 import logging
 import os
 from uuid import UUID
-from typing import Any, Dict, ForwardRef, Generic, Iterator, List, Optional, Tuple, Type, TypeVar, Union, cast, get_args
+from typing import Any, Dict, ForwardRef, Generic, List, Optional, Tuple, Type, TypeVar, Union, cast, get_args
 
 from vellum.client import Vellum as VellumClient
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
@@ -96,8 +96,6 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
     # Used to explicitly specify display data for a workflow's ports.
     port_displays: PortDisplays = {}
 
-    _errors: List[Exception]
-
     _serialized_files: List[str]
 
     _dry_run: bool
@@ -116,7 +114,6 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             if self._parent_display_context
             else create_vellum_client()
         )
-        self._errors = []
         self._serialized_files = []
         self._dry_run = dry_run
 
@@ -196,7 +193,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             try:
                 serialized_node = node_display.serialize(self.display_context)
             except (NotImplementedError, NodeValidationError) as e:
-                self.add_error(e)
+                self.display_context.add_error(e)
                 continue
 
             serialized_nodes[node_display.node_id] = serialized_node
@@ -315,7 +312,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         # If there are terminal nodes with no workflow output reference,
         # raise a serialization error
         if len(unreferenced_final_output_node_outputs) > 0:
-            self.add_error(
+            self.display_context.add_error(
                 ValueError("Unable to serialize terminal nodes that are not referenced by workflow outputs.")
             )
 
@@ -375,7 +372,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             try:
                 self._apply_auto_layout(nodes_dict_list, edges)
             except Exception as e:
-                self.add_error(e)
+                self.display_context.add_error(e)
 
         return {
             "workflow_raw_data": {
@@ -446,17 +443,6 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         """Can be overridden as a class attribute to specify a custom workflow id."""
         return self._workflow.__id__
 
-    def add_error(self, error: Exception) -> None:
-        if self._dry_run:
-            self._errors.append(error)
-            return
-
-        raise error
-
-    @property
-    def errors(self) -> Iterator[Exception]:
-        return iter(self._errors)
-
     def _enrich_global_node_output_displays(
         self,
         node: Type[BaseNode],
@@ -606,6 +592,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             edge_displays=edge_displays,
             port_displays=port_displays,
             workflow_display_class=self.__class__,
+            _dry_run=self._dry_run,
         )
 
     def _generate_workflow_meta_display(self) -> WorkflowMetaDisplay:
@@ -896,7 +883,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
 
         return WorkflowSerializationResult(
             exec_config=exec_config,
-            errors=[str(error) for error in workflow_display.errors],
+            errors=[str(error) for error in workflow_display.display_context.errors],
         )
 
     def _gather_additional_module_files(self, module_path: str) -> Dict[str, str]:

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/pyproject.toml

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

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/src/vellum/__init__.py

@@ -525,7 +525,14 @@ from .client.types import (
     VellumVariable,
     VellumVariableExtensions,
     VellumVariableType,
+    VellumVideo,
+    VellumVideoRequest,
     VellumWorkflowExecutionEvent,
+    VideoChatMessageContent,
+    VideoChatMessageContentRequest,
+    VideoPromptBlock,
+    VideoVellumValue,
+    VideoVellumValueRequest,
     WorkflowDeploymentEventExecutionsResponse,
     WorkflowDeploymentHistoryItem,
     WorkflowDeploymentParentContext,
@@ -562,6 +569,7 @@ from .client.types import (
     WorkflowExecutionStreamingEvent,
     WorkflowExecutionUsageCalculationError,
     WorkflowExecutionUsageCalculationErrorCodeEnum,
+    WorkflowExecutionUsageCalculationFulfilledBody,
     WorkflowExecutionUsageResult,
     WorkflowExecutionViewOnlineEvalMetricResult,
     WorkflowExecutionWorkflowResultEvent,
@@ -1175,7 +1183,14 @@ __all__ = [
     "VellumVariable",
     "VellumVariableExtensions",
     "VellumVariableType",
+    "VellumVideo",
+    "VellumVideoRequest",
     "VellumWorkflowExecutionEvent",
+    "VideoChatMessageContent",
+    "VideoChatMessageContentRequest",
+    "VideoPromptBlock",
+    "VideoVellumValue",
+    "VideoVellumValueRequest",
     "WorkflowDeploymentEventExecutionsResponse",
     "WorkflowDeploymentHistoryItem",
     "WorkflowDeploymentParentContext",
@@ -1213,6 +1228,7 @@ __all__ = [
     "WorkflowExecutionStreamingEvent",
     "WorkflowExecutionUsageCalculationError",
     "WorkflowExecutionUsageCalculationErrorCodeEnum",
+    "WorkflowExecutionUsageCalculationFulfilledBody",
     "WorkflowExecutionUsageResult",
     "WorkflowExecutionViewOnlineEvalMetricResult",
     "WorkflowExecutionWorkflowResultEvent",

{vellum_ai-1.1.2 → vellum_ai-1.1.3}/src/vellum/client/README.md

@@ -95,6 +95,61 @@ except ApiError as e:
     print(e.body)
 ```
 
+## Streaming
+
+The SDK supports streaming responses, as well, the response will be a generator that you can loop over.
+
+```python
+from vellum import (
+    JinjaPromptBlock,
+    PromptParameters,
+    PromptRequestStringInput,
+    Vellum,
+    VellumVariable,
+)
+
+client = Vellum(
+    api_version="YOUR_API_VERSION",
+    api_key="YOUR_API_KEY",
+)
+response = client.ad_hoc.adhoc_execute_prompt_stream(
+    ml_model="x",
+    input_values=[
+        PromptRequestStringInput(
+            key="x",
+            value="value",
+        ),
+        PromptRequestStringInput(
+            key="x",
+            value="value",
+        ),
+    ],
+    input_variables=[
+        VellumVariable(
+            id="x",
+            key="key",
+            type="STRING",
+        ),
+        VellumVariable(
+            id="x",
+            key="key",
+            type="STRING",
+        ),
+    ],
+    parameters=PromptParameters(),
+    blocks=[
+        JinjaPromptBlock(
+            template="template",
+        ),
+        JinjaPromptBlock(
+            template="template",
+        ),
+    ],
+)
+for chunk in response.data:
+    yield chunk
+```
+
 ## Advanced
 
 ### Retries