vellum-ai 1.1.5__py3-none-any.whl → 1.2.1__py3-none-any.whl

vellum/client/types/error_detail_response.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class ErrorDetailResponse(UniversalBaseModel):
+    detail: str = pydantic.Field()
+    """
+    Message informing the user of the error.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/client/types/event_create_response.py

@@ -0,0 +1,26 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class EventCreateResponse(UniversalBaseModel):
+    """
+    Response serializer for successful event creation.
+    """
+
+    success: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Indicates whether the event was published successfully.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/client/types/execution_thinking_vellum_value.py

@@ -19,7 +19,7 @@ class ExecutionThinkingVellumValue(UniversalBaseModel):
 
     name: str
     type: typing.Literal["THINKING"] = "THINKING"
-    value: StringVellumValue
+    value: typing.Optional[StringVellumValue] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/thinking_vellum_value.py

@@ -13,7 +13,7 @@ class ThinkingVellumValue(UniversalBaseModel):
     """
 
     type: typing.Literal["THINKING"] = "THINKING"
-    value: StringVellumValue
+    value: typing.Optional[StringVellumValue] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/thinking_vellum_value_request.py

@@ -13,7 +13,7 @@ class ThinkingVellumValueRequest(UniversalBaseModel):
     """
 
     type: typing.Literal["THINKING"] = "THINKING"
-    value: StringVellumValueRequest
+    value: typing.Optional[StringVellumValueRequest] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/workflow_event.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from .node_execution_fulfilled_event import NodeExecutionFulfilledEvent
+from .node_execution_initiated_event import NodeExecutionInitiatedEvent
+from .node_execution_paused_event import NodeExecutionPausedEvent
+from .node_execution_rejected_event import NodeExecutionRejectedEvent
+from .node_execution_resumed_event import NodeExecutionResumedEvent
+from .node_execution_streaming_event import NodeExecutionStreamingEvent
+from .workflow_execution_fulfilled_event import WorkflowExecutionFulfilledEvent
+from .workflow_execution_initiated_event import WorkflowExecutionInitiatedEvent
+from .workflow_execution_paused_event import WorkflowExecutionPausedEvent
+from .workflow_execution_rejected_event import WorkflowExecutionRejectedEvent
+from .workflow_execution_resumed_event import WorkflowExecutionResumedEvent
+from .workflow_execution_snapshotted_event import WorkflowExecutionSnapshottedEvent
+from .workflow_execution_streaming_event import WorkflowExecutionStreamingEvent
+
+WorkflowEvent = typing.Union[
+    NodeExecutionInitiatedEvent,
+    NodeExecutionStreamingEvent,
+    NodeExecutionFulfilledEvent,
+    NodeExecutionRejectedEvent,
+    NodeExecutionPausedEvent,
+    NodeExecutionResumedEvent,
+    WorkflowExecutionInitiatedEvent,
+    WorkflowExecutionStreamingEvent,
+    WorkflowExecutionRejectedEvent,
+    WorkflowExecutionFulfilledEvent,
+    WorkflowExecutionPausedEvent,
+    WorkflowExecutionResumedEvent,
+    WorkflowExecutionSnapshottedEvent,
+]

vellum/errors/too_many_requests_error.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.errors.too_many_requests_error import *

vellum/errors/unauthorized_error.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.errors.unauthorized_error import *

vellum/resources/events/__init__.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.resources.events import *

vellum/resources/events/client.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.resources.events.client import *

vellum/resources/events/raw_client.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.resources.events.raw_client import *

vellum/types/error_detail_response.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.error_detail_response import *

vellum/types/event_create_response.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.event_create_response import *

vellum/types/workflow_event.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.workflow_event import *

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -14,6 +14,7 @@ from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.types.core import Json, MergeBehavior, VellumSecret
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.utils.hmac import sign_request_with_env_secret
 
 
 class BaseAPINode(BaseNode, Generic[StateType]):
@@ -105,6 +106,9 @@ class BaseAPINode(BaseNode, Generic[StateType]):
                 prepped = Request(method=method, url=url, headers=headers).prepare()
         except Exception as e:
             raise NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
+
+        sign_request_with_env_secret(prepped)
+
         try:
             with Session() as session:
                 response = session.send(prepped, timeout=timeout)

vellum/workflows/nodes/displayable/bases/api_node/tests/test_node.py

@@ -1,4 +1,6 @@
 import pytest
+import os
+from unittest.mock import patch
 
 from vellum.client.types.execute_api_response import ExecuteApiResponse
 from vellum.workflows.constants import APIRequestMethod
@@ -122,3 +124,27 @@ def test_api_node_preserves_custom_user_agent_header(requests_mock):
     assert response_mock.last_request.headers.get("User-Agent") == "Custom-Agent/1.0"
 
     assert result.status_code == 200
+
+
+def test_local_execute_api_with_hmac_secret(requests_mock):
+    """Test that _local_execute_api adds HMAC headers when VELLUM_HMAC_SECRET is set."""
+
+    class TestAPINode(BaseAPINode):
+        method = APIRequestMethod.POST
+        url = "https://example.com/test"
+        json = {"test": "data"}
+
+    response_mock = requests_mock.post(
+        "https://example.com/test",
+        json={"result": "success"},
+        status_code=200,
+    )
+
+    with patch.dict(os.environ, {"VELLUM_HMAC_SECRET": "test-secret"}):
+        node = TestAPINode()
+        result = node.run()
+
+    assert response_mock.last_request
+    assert "X-Vellum-Timestamp" in response_mock.last_request.headers
+    assert "X-Vellum-Signature" in response_mock.last_request.headers
+    assert result.status_code == 200

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

@@ -122,8 +122,13 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                     )
                 elif is_workflow_class(function):
                     normalized_functions.append(compile_inline_workflow_function_definition(function))
-                else:
+                elif callable(function):
                     normalized_functions.append(compile_function_definition(function))
+                else:
+                    raise NodeException(
+                        message=f"`{function}` is not a valid function definition",
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                    )
 
         if self.settings and not self.settings.stream_enabled:
             # This endpoint is returning a single event, so we need to wrap it in a generator

vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -662,3 +662,25 @@ def test_inline_prompt_node__dict_blocks_error(vellum_adhoc_prompt_client):
     # THEN the node should raise the correct NodeException
     assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
     assert "Failed to compile blocks" == str(excinfo.value)
+
+
+def test_inline_prompt_node__invalid_function_type():
+    """Test that the node raises an error when an invalid function type is passed."""
+
+    # GIVEN a node that has an invalid function type (not dict or callable)
+    class MyInlinePromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = []
+        prompt_inputs = {}
+        functions = ["not_a_function"]  # type: ignore
+
+    # WHEN the node is created
+    node = MyInlinePromptNode()
+
+    # THEN the node should raise a NodeException with the correct error code
+    with pytest.raises(NodeException) as excinfo:
+        list(node.run())
+
+    # AND the error should have the correct code and message
+    assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "`not_a_function` is not a valid function definition" == str(excinfo.value)

vellum/workflows/sandbox.py

@@ -1,4 +1,4 @@
-from typing import Generic, Sequence
+from typing import Generic, Optional, Sequence
 
 import dotenv
 
@@ -10,16 +10,36 @@ from vellum.workflows.workflows.event_filters import root_workflow_event_filter
 
 
 class WorkflowSandboxRunner(Generic[WorkflowType]):
-    def __init__(self, workflow: WorkflowType, inputs: Sequence[BaseInputs]):
-        if not inputs:
-            raise ValueError("Inputs are required to have at least one defined inputs")
-
-        self._workflow = workflow
-        self._inputs = inputs
-
+    def __init__(
+        self,
+        workflow: WorkflowType,
+        inputs: Optional[Sequence[BaseInputs]] = None,  # DEPRECATED - remove in v2.0.0
+        dataset: Optional[Sequence[BaseInputs]] = None,
+    ):
         dotenv.load_dotenv()
         self._logger = load_logger()
 
+        if dataset is not None and inputs is not None:
+            raise ValueError(
+                "Cannot specify both 'dataset' and 'inputs' parameters. " "Use 'dataset' as 'inputs' is deprecated."
+            )
+
+        if dataset is not None:
+            actual_inputs = dataset
+        elif inputs is not None:
+            self._logger.warning(
+                "The 'inputs' parameter is deprecated and will be removed in v2.0.0. " "Please use 'dataset' instead."
+            )
+            actual_inputs = inputs
+        else:
+            raise ValueError("Either 'dataset' or 'inputs' parameter is required")
+
+        if not actual_inputs:
+            raise ValueError("Dataset/inputs are required to have at least one defined input")
+
+        self._workflow = workflow
+        self._inputs = actual_inputs
+
     def run(self, index: int = 0):
         if index < 0:
             self._logger.warning("Index is less than 0, running first input")

vellum/workflows/state/encoder.py

@@ -2,8 +2,10 @@ from dataclasses import asdict, is_dataclass
 from datetime import datetime
 import enum
 import inspect
+from io import StringIO
 from json import JSONEncoder
 from queue import Queue
+import sys
 from uuid import UUID
 from typing import Any, Callable, Dict, Type
 
@@ -18,6 +20,22 @@ from vellum.workflows.state.base import BaseState, NodeExecutionCache
 from vellum.workflows.utils.functions import compile_function_definition
 
 
+def virtual_open(file_path: str, mode: str = "r"):
+    """
+    Open a file, checking VirtualFileFinder instances first before falling back to regular open().
+    """
+    for finder in sys.meta_path:
+        if hasattr(finder, "loader") and hasattr(finder.loader, "_get_code"):
+            namespace = finder.loader.namespace
+            if file_path.startswith(namespace + "/"):
+                relative_path = file_path[len(namespace) + 1 :]
+                content = finder.loader._get_code(relative_path)
+                if content is not None:
+                    return StringIO(content)
+
+    return open(file_path, mode)
+
+
 class DefaultStateEncoder(JSONEncoder):
     encoders: Dict[Type, Callable] = {}
 
@@ -66,7 +84,7 @@ class DefaultStateEncoder(JSONEncoder):
             function_definition = compile_function_definition(obj)
             source_path = inspect.getsourcefile(obj)
             if source_path is not None:
-                with open(source_path) as f:
+                with virtual_open(source_path) as f:
                     source_code = f.read()
             else:
                 source_code = f"# Error: Source code not available for {obj.__name__}"

vellum/workflows/utils/hmac.py

@@ -0,0 +1,44 @@
+import hashlib
+import hmac
+import os
+import time
+
+from requests import PreparedRequest
+
+
+def _sign_request(request: PreparedRequest, secret: str) -> None:
+    """
+    Sign a request with HMAC using the same pattern as Django implementation.
+
+    Args:
+        request: The prepared request to sign
+        secret: The HMAC secret string
+    """
+    timestamp = str(int(time.time()))
+
+    body = request.body or b""
+    if isinstance(body, str):
+        body = body.encode()
+
+    message = f"{timestamp}\n{request.method}\n{request.url}\n".encode() + body
+
+    signature = hmac.new(secret.encode("utf-8"), message, hashlib.sha256).hexdigest()
+
+    hmac_headers = {
+        "X-Vellum-Timestamp": timestamp,
+        "X-Vellum-Signature": signature,
+    }
+
+    request.headers.update(hmac_headers)
+
+
+def sign_request_with_env_secret(request: PreparedRequest) -> None:
+    """
+    Sign a request using VELLUM_HMAC_SECRET environment variable if available.
+
+    Args:
+        request: The prepared request to sign
+    """
+    hmac_secret = os.environ.get("VELLUM_HMAC_SECRET")
+    if hmac_secret:
+        _sign_request(request, hmac_secret)

{vellum_ai-1.1.5.dist-info → vellum_ai-1.2.1.dist-info}/METADATA

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