vellum-ai 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

vellum/workflows/nodes/displayable/web_search_node/tests/test_node.py

@@ -0,0 +1,319 @@
+import pytest
+from unittest.mock import MagicMock
+
+import requests
+
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.state import BaseState
+from vellum.workflows.state.base import StateMeta
+
+from ..node import WebSearchNode
+
+
+@pytest.fixture
+def base_node_setup(vellum_client):
+    """Basic node setup with required inputs."""
+
+    class Inputs(BaseInputs):
+        query: str
+        api_key: str
+        num_results: int
+
+    class State(BaseState):
+        pass
+
+    class TestableWebSearchNode(WebSearchNode):
+        query = Inputs.query
+        api_key = Inputs.api_key
+        num_results = Inputs.num_results
+
+    state = State(meta=StateMeta(workflow_inputs=Inputs(query="test query", api_key="test_api_key", num_results=3)))
+    context = MagicMock()
+    context.vellum_client = vellum_client
+    node = TestableWebSearchNode(state=state, context=context)
+    return node
+
+
+def test_successful_search_with_results(base_node_setup, requests_mock):
+    """Test successful SerpAPI search with typical organic results."""
+    # GIVEN a mock SerpAPI response with organic results
+    mock_response = {
+        "organic_results": [
+            {
+                "title": "First Result",
+                "snippet": "This is the first search result snippet",
+                "link": "https://example1.com",
+                "position": 1,
+            },
+            {
+                "title": "Second Result",
+                "snippet": "This is the second search result snippet",
+                "link": "https://example2.com",
+                "position": 2,
+            },
+            {
+                "title": "Third Result",
+                "snippet": "This is the third search result snippet",
+                "link": "https://example3.com",
+                "position": 3,
+            },
+        ]
+    }
+
+    requests_mock.get("https://serpapi.com/search", json=mock_response)
+
+    # WHEN we run the node
+    outputs = base_node_setup.run()
+
+    # THEN the text output should be properly formatted
+    expected_text = (
+        "First Result: This is the first search result snippet\n\n"
+        "Second Result: This is the second search result snippet\n\n"
+        "Third Result: This is the third search result snippet"
+    )
+    assert outputs.text == expected_text
+
+    # AND URLs should be extracted correctly
+    assert outputs.urls == ["https://example1.com", "https://example2.com", "https://example3.com"]
+
+    # AND raw results should be preserved
+    assert outputs.results == mock_response["organic_results"]
+
+    # AND the request should have the correct parameters
+    assert requests_mock.last_request.qs == {
+        "q": ["test query"],
+        "api_key": ["test_api_key"],
+        "num": ["3"],
+        "engine": ["google"],
+    }
+
+
+def test_search_with_location_parameter(base_node_setup, requests_mock):
+    """Test that location parameter is properly passed to SerpAPI."""
+    # GIVEN a location parameter is set
+    base_node_setup.location = "New York, NY"
+
+    requests_mock.get("https://serpapi.com/search", json={"organic_results": []})
+
+    # WHEN we run the node
+    base_node_setup.run()
+
+    # THEN the location parameter should be included (URL encoding may lowercase)
+    assert "location" in requests_mock.last_request.qs
+    assert requests_mock.last_request.qs["location"][0].lower() == "new york, ny"
+
+
+def test_authentication_error_401(base_node_setup, requests_mock):
+    """Test 401 authentication error raises NodeException with INVALID_INPUTS."""
+    # GIVEN SerpAPI returns a 401 authentication error
+    requests_mock.get("https://serpapi.com/search", status_code=401)
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        base_node_setup.run()
+
+    # THEN it should raise the appropriate error
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Invalid API key" in str(exc_info.value)
+
+
+def test_rate_limit_error_429(base_node_setup, requests_mock):
+    """Test 429 rate limit error raises NodeException with PROVIDER_ERROR."""
+    # GIVEN SerpAPI returns a 429 rate limit error
+    requests_mock.get("https://serpapi.com/search", status_code=429)
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        base_node_setup.run()
+
+    # THEN it should raise the appropriate error
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_ERROR
+    assert "Rate limit exceeded" in str(exc_info.value)
+
+
+def test_server_error_500(base_node_setup, requests_mock):
+    """Test 500+ server errors raise NodeException with PROVIDER_ERROR."""
+    # GIVEN SerpAPI returns a 500 server error
+    requests_mock.get("https://serpapi.com/search", status_code=500)
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        base_node_setup.run()
+
+    # THEN it should raise the appropriate error
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_ERROR
+    assert "SerpAPI error: HTTP 500" in str(exc_info.value)
+
+
+def test_invalid_json_response(base_node_setup, requests_mock):
+    """Test non-JSON response raises appropriate NodeException."""
+    # GIVEN SerpAPI returns non-JSON content
+    requests_mock.get("https://serpapi.com/search", text="Not JSON")
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        base_node_setup.run()
+
+    # THEN it should raise the appropriate error
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_ERROR
+    assert "Invalid JSON response" in str(exc_info.value)
+
+
+def test_serpapi_error_in_response(base_node_setup, requests_mock):
+    """Test SerpAPI error field in response raises NodeException."""
+    # GIVEN SerpAPI returns an error in the response body
+    requests_mock.get("https://serpapi.com/search", json={"error": "Invalid search parameters"})
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        base_node_setup.run()
+
+    # THEN it should raise the appropriate error
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_ERROR
+    assert "Invalid search parameters" in str(exc_info.value)
+
+
+def test_empty_query_validation(vellum_client):
+    """Test empty query raises validation error."""
+
+    # GIVEN a node with an empty query
+    class TestNode(WebSearchNode):
+        query = ""
+        api_key = "test_key"
+        num_results = 10
+
+    context = MagicMock()
+    context.vellum_client = vellum_client
+    node = TestNode(state=BaseState(meta=StateMeta(workflow_inputs=BaseInputs())), context=context)
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN it should raise a validation error
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Query is required" in str(exc_info.value)
+
+
+def test_missing_api_key_validation(vellum_client):
+    """Test missing API key raises validation error."""
+
+    # GIVEN a node with no API key
+    class TestNode(WebSearchNode):
+        query = "test query"
+        api_key = None
+        num_results = 10
+
+    context = MagicMock()
+    context.vellum_client = vellum_client
+    node = TestNode(state=BaseState(meta=StateMeta(workflow_inputs=BaseInputs())), context=context)
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN it should raise a validation error
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "API key is required" in str(exc_info.value)
+
+
+def test_invalid_num_results_validation(vellum_client):
+    """Test invalid num_results raises validation error."""
+
+    # GIVEN a node with invalid num_results
+    class TestNode(WebSearchNode):
+        query = "test query"
+        api_key = "test_key"
+        num_results = -1
+
+    context = MagicMock()
+    context.vellum_client = vellum_client
+    node = TestNode(state=BaseState(meta=StateMeta(workflow_inputs=BaseInputs())), context=context)
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN it should raise a validation error
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "num_results must be a positive integer" in str(exc_info.value)
+
+
+def test_empty_organic_results(base_node_setup, requests_mock):
+    """Test handling of empty search results."""
+    # GIVEN SerpAPI returns no organic results
+    requests_mock.get("https://serpapi.com/search", json={"organic_results": []})
+
+    # WHEN we run the node
+    outputs = base_node_setup.run()
+
+    # THEN all outputs should be empty
+    assert outputs.text == ""
+    assert outputs.urls == []
+    assert outputs.results == []
+
+
+def test_missing_fields_in_results(base_node_setup, requests_mock):
+    """Test handling of missing title, snippet, or link fields."""
+    # GIVEN SerpAPI returns results with missing fields
+    mock_response = {
+        "organic_results": [
+            {
+                "title": "Only Title",
+                # Missing snippet and link
+            },
+            {
+                "snippet": "Only snippet, no title or link"
+                # Missing title and link
+            },
+            {
+                "title": "Title with link",
+                "link": "https://example.com",
+                # Missing snippet
+            },
+            {
+                # All fields missing - should be skipped
+                "position": 4
+            },
+        ]
+    }
+
+    requests_mock.get("https://serpapi.com/search", json=mock_response)
+
+    # WHEN we run the node
+    outputs = base_node_setup.run()
+
+    # THEN text should handle missing fields gracefully
+    expected_text = "Only Title\n\n" "Only snippet, no title or link\n\n" "Title with link"
+    assert outputs.text == expected_text
+
+    # AND URLs should only include valid links
+    assert outputs.urls == ["https://example.com"]
+
+
+def test_request_timeout_handling(base_node_setup, requests_mock):
+    """Test network timeout raises appropriate error."""
+    # GIVEN a network timeout occurs
+    requests_mock.get("https://serpapi.com/search", exc=requests.exceptions.Timeout("Connection timed out"))
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as exc_info:
+        base_node_setup.run()
+
+    # THEN it should raise a provider error
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_ERROR
+    assert "HTTP request failed" in str(exc_info.value)
+
+
+def test_user_agent_header_included(base_node_setup, requests_mock):
+    """Test that User-Agent header from vellum_client is included."""
+    # GIVEN a successful request
+    requests_mock.get("https://serpapi.com/search", json={"organic_results": []})
+
+    # WHEN we run the node
+    base_node_setup.run()
+
+    # THEN the User-Agent header should be included
+    assert requests_mock.last_request.headers["User-Agent"] == "vellum-python-sdk/1.0.0"

vellum/workflows/nodes/tests/test_utils.py

@@ -150,3 +150,26 @@ def test_cast_to_output_type_none_value(output_type, expected_result):
     """Test that cast_to_output_type returns appropriate default values when None is provided."""
     result = cast_to_output_type(None, output_type)
     assert result == expected_result
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_result",
+    [
+        ('{"name": "Alice", "age": 30}', {"name": "Alice", "age": 30}),
+        ("[1, 2, 3]", [1, 2, 3]),
+        ("invalid json", "invalid json"),
+        ([1, 2, 3], [1, 2, 3]),
+        ({"already": "dict"}, {"already": "dict"}),
+    ],
+    ids=[
+        "valid_json_object",
+        "valid_json_array",
+        "invalid_json_string",
+        "non_string_list",
+        "non_string_dict",
+    ],
+)
+def test_cast_to_output_type_any_json_parsing(input_value, expected_result):
+    """Test that cast_to_output_type attempts JSON parsing for Any type and falls back gracefully."""
+    result = cast_to_output_type(input_value, Any)
+    assert result == expected_result

vellum/workflows/nodes/utils.py

@@ -8,6 +8,7 @@ from typing import Any, Callable, Dict, ForwardRef, List, Optional, Type, TypeVa
 from pydantic import BaseModel, create_model
 
 from vellum.client.types.function_call import FunctionCall
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
@@ -253,6 +254,19 @@ def cast_to_output_type(result: Any, output_type: Any) -> Any:
     if result is None:
         return _get_default_value(output_type)
 
+    if result is undefined:
+        return _get_default_value(output_type)
+
+    # Attempt JSON parse if type is Any
+    if output_type is Any:
+        if isinstance(result, str):
+            try:
+                return json.loads(result)
+            except (json.JSONDecodeError, TypeError):
+                # If JSON parsing fails, fall back to original result
+                pass
+        return result
+
     clean_output_type = _clean_output_type(output_type)
     DynamicModel = create_model("Output", output_type=(clean_output_type, ...))
 

vellum/workflows/runner/runner.py

@@ -404,6 +404,7 @@ class WorkflowRunner(Generic[StateType]):
             )
         except NodeException as e:
             logger.info(e)
+            captured_traceback = traceback.format_exc()
 
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
@@ -412,12 +413,14 @@ class WorkflowRunner(Generic[StateType]):
                     body=NodeExecutionRejectedBody(
                         node_definition=node.__class__,
                         error=e.error,
+                        traceback=captured_traceback,
                     ),
                     parent=execution.parent_context,
                 )
             )
         except WorkflowInitializationException as e:
             logger.info(e)
+            captured_traceback = traceback.format_exc()
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
                     trace_id=execution.trace_id,
@@ -425,6 +428,7 @@ class WorkflowRunner(Generic[StateType]):
                     body=NodeExecutionRejectedBody(
                         node_definition=node.__class__,
                         error=e.error,
+                        traceback=captured_traceback,
                     ),
                     parent=execution.parent_context,
                 )
@@ -574,7 +578,7 @@ class WorkflowRunner(Generic[StateType]):
             )
             worker_thread.start()
 
-    def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[WorkflowError]:
+    def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[NodeExecutionRejectedEvent]:
         active_node = self._active_nodes_by_execution_id.get(event.span_id)
         if not active_node:
             return None
@@ -582,7 +586,7 @@ class WorkflowRunner(Generic[StateType]):
         node = active_node.node
         if event.name == "node.execution.rejected":
             self._active_nodes_by_execution_id.pop(event.span_id)
-            return event.error
+            return event
 
         if event.name == "node.execution.streaming":
             for workflow_output_descriptor in self.workflow.Outputs:
@@ -708,13 +712,24 @@ class WorkflowRunner(Generic[StateType]):
             parent=self._execution_context.parent_context,
         )
 
-    def _reject_workflow_event(self, error: WorkflowError) -> WorkflowExecutionRejectedEvent:
+    def _reject_workflow_event(
+        self, error: WorkflowError, captured_traceback: Optional[str] = None
+    ) -> WorkflowExecutionRejectedEvent:
+        if captured_traceback is None:
+            try:
+                captured_traceback = traceback.format_exc()
+                if captured_traceback.strip() == "NoneType: None":
+                    captured_traceback = None
+            except Exception:
+                pass
+
         return WorkflowExecutionRejectedEvent(
             trace_id=self._execution_context.trace_id,
             span_id=self._initial_state.meta.span_id,
             body=WorkflowExecutionRejectedBody(
                 workflow_definition=self.workflow.__class__,
                 error=error,
+                traceback=captured_traceback,
             ),
             parent=self._execution_context.parent_context,
         )
@@ -758,22 +773,26 @@ class WorkflowRunner(Generic[StateType]):
                 else:
                     self._concurrency_queue.put((self._initial_state, node_cls, None))
             except NodeException as e:
-                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error))
+                captured_traceback = traceback.format_exc()
+                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error, captured_traceback))
                 return
             except WorkflowInitializationException as e:
-                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error))
+                captured_traceback = traceback.format_exc()
+                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error, captured_traceback))
                 return
             except Exception:
                 err_message = f"An unexpected error occurred while initializing node {node_cls.__name__}"
                 logger.exception(err_message)
+                captured_traceback = traceback.format_exc()
                 self._workflow_event_outer_queue.put(
                     self._reject_workflow_event(
                         WorkflowError(code=WorkflowErrorCode.INTERNAL_ERROR, message=err_message),
+                        captured_traceback,
                     )
                 )
                 return
 
-        rejection_error: Optional[WorkflowError] = None
+        rejection_event: Optional[NodeExecutionRejectedEvent] = None
 
         while True:
             if not self._active_nodes_by_execution_id:
@@ -784,9 +803,9 @@ class WorkflowRunner(Generic[StateType]):
             self._workflow_event_outer_queue.put(event)
 
             with execution_context(parent_context=current_parent, trace_id=self._execution_context.trace_id):
-                rejection_error = self._handle_work_item_event(event)
+                rejection_event = self._handle_work_item_event(event)
 
-            if rejection_error:
+            if rejection_event:
                 break
 
         # Handle any remaining events
@@ -795,9 +814,9 @@ class WorkflowRunner(Generic[StateType]):
                 self._workflow_event_outer_queue.put(event)
 
                 with execution_context(parent_context=current_parent, trace_id=self._execution_context.trace_id):
-                    rejection_error = self._handle_work_item_event(event)
+                    rejection_event = self._handle_work_item_event(event)
 
-                if rejection_error:
+                if rejection_event:
                     break
         except Empty:
             pass
@@ -817,8 +836,10 @@ class WorkflowRunner(Generic[StateType]):
             )
             return
 
-        if rejection_error:
-            self._workflow_event_outer_queue.put(self._reject_workflow_event(rejection_error))
+        if rejection_event:
+            self._workflow_event_outer_queue.put(
+                self._reject_workflow_event(rejection_event.error, rejection_event.body.traceback)
+            )
             return
 
         fulfilled_outputs = self.workflow.Outputs()

vellum/workflows/types/code_execution_node_wrappers.py

@@ -1,4 +1,5 @@
 from vellum.client.types.function_call import FunctionCall
+from vellum.workflows.constants import undefined
 
 
 class StringValueWrapper(str):
@@ -71,7 +72,7 @@ class DictWrapper(dict):
                 # several values as VellumValue objects, we use the "value" key to return itself
                 return self
 
-            raise AttributeError(f"dict has no key: '{attr}'")
+            return undefined
 
         item = super().__getitem__(attr)
         if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):

{vellum_ai-1.3.0.dist-info → vellum_ai-1.3.2.dist-info}/METADATA

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