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

vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.3.0",
+            "User-Agent": "vellum-ai/1.3.1",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.0",
+            "X-Fern-SDK-Version": "1.3.1",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/workflows/events/workflow.py

@@ -1,3 +1,4 @@
+import logging
 from uuid import UUID
 from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Literal, Optional, Type, Union
 from typing_extensions import TypeGuard
@@ -25,6 +26,8 @@ from .types import BaseEvent, default_serializer
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
 
+logger = logging.getLogger(__name__)
+
 
 class _BaseWorkflowExecutionBody(UniversalBaseModel):
     workflow_definition: Type["BaseWorkflow"]
@@ -107,8 +110,12 @@ class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[InputsType, St
     ) -> WorkflowExecutionInitiatedBody[InputsType, StateType]:
         context = info.context if info and hasattr(info, "context") else {}
         if context and "event_enricher" in context and callable(context["event_enricher"]):
-            event = context["event_enricher"](self)
-            return event.body
+            try:
+                event = context["event_enricher"](self)
+                return event.body
+            except Exception as e:
+                logger.exception(f"Error in event_enricher: {e}")
+                return body
         else:
             return body
 

vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -54,12 +54,23 @@ class FunctionCallNodeMixin:
                 return function_call.value.arguments or {}
         return {}
 
+    def _extract_function_call_id(self) -> Optional[str]:
+        """Extract function call ID from function call output."""
+        current_index = getattr(self, "state").current_prompt_output_index
+        if self.function_call_output and len(self.function_call_output) > current_index:
+            function_call = self.function_call_output[current_index]
+            if function_call.type == "FUNCTION_CALL" and function_call.value is not None:
+                return function_call.value.id
+        return None
+
     def _add_function_result_to_chat_history(self, result: Any, state: ToolCallingState) -> None:
         """Add function execution result to chat history."""
+        function_call_id = self._extract_function_call_id()
         state.chat_history.append(
             ChatMessage(
                 role="FUNCTION",
                 content=StringChatMessageContent(value=json.dumps(result, cls=DefaultStateEncoder)),
+                source=function_call_id,
             )
         )
         with state.__quiet__():

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_ai-1.3.0.dist-info → vellum_ai-1.3.1.dist-info}/METADATA

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

{vellum_ai-1.3.0.dist-info → vellum_ai-1.3.1.dist-info}/RECORD

@@ -106,7 +106,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_workflow_input_par
 vellum_ee/workflows/display/types.py,sha256=cyZruu4sXAdHjwuFc7dydM4DcFNf-pp_CmulXItxac4,3679
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/auto_layout.py,sha256=f4GiLn_LazweupfqTpubcdtdfE_vrOcmZudSsnYIY9E,3906
-vellum_ee/workflows/display/utils/events.py,sha256=HHKXnVy1Zs0YJxTojp2iKQJFTLBqVXiY-YW0J-rRZlI,1673
+vellum_ee/workflows/display/utils/events.py,sha256=KC684ZWODHRGgJtik_KjGXIjM5x4_58_1dGuco_9O8c,1748
 vellum_ee/workflows/display/utils/exceptions.py,sha256=LSwwxCYNxFkf5XMUcFkaZKpQ13OSrI7y_bpEUwbKVk0,169
 vellum_ee/workflows/display/utils/expressions.py,sha256=yPrUIEQKL5fDwUC9NpVO9yjL6emTOdFJw8VjoZgZ0E0,16942
 vellum_ee/workflows/display/utils/registry.py,sha256=1qXiBTdsnro6FeCX0FGBEK7CIf6wa--Jt50iZ_nEp_M,3460
@@ -150,7 +150,7 @@ vellum/client/README.md,sha256=Uwq9qIFZAHOVCgEfatfWe4YoW-QYYy6xVA1bMjPvx3k,5601
 vellum/client/__init__.py,sha256=LOu_TklkJG01SgXIpPWDhOX2QvKDyd2ZbQyr5H0m31I,72349
 vellum/client/core/__init__.py,sha256=lTcqUPXcx4112yLDd70RAPeqq6tu3eFMe1pKOqkW9JQ,1562
 vellum/client/core/api_error.py,sha256=44vPoTyWN59gonCIZMdzw7M1uspygiLnr3GNFOoVL2Q,614
-vellum/client/core/client_wrapper.py,sha256=4fuXhB590QTj5qI353Y_5rFqDeErbqxyPvpM_U8GaL4,2840
+vellum/client/core/client_wrapper.py,sha256=yjqDTK-pFWVYr-n4F1kmy-TuBlGzXJBmaztIfr5uBF0,2840
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/force_multipart.py,sha256=awxh5MtcRYe74ehY8U76jzv6fYM_w_D3Rur7KQQzSDk,429
@@ -1727,7 +1727,7 @@ vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 vellum/workflows/events/tests/test_basic_workflow.py,sha256=Pj6orHsXz37jWC5FARi0Sx2Gjf99Owri2Cvr6Chb79k,1765
 vellum/workflows/events/tests/test_event.py,sha256=c2pM8ZOuES_8XjLYP4cU4cChrZUZ1ZZ3HUNIaaPAxXk,18411
 vellum/workflows/events/types.py,sha256=mVrqAH9Hs9SpXm08Hcxdyap_ImQPwGsxRr56rSNMP34,5043
-vellum/workflows/events/workflow.py,sha256=gjg4Dt5i40jaTMK_-AaGtW9lzX1JGn3FUAu1XqhduJ8,8753
+vellum/workflows/events/workflow.py,sha256=rAj2jH94t-bWqtQRtG8mkxXpQxIfqux06QtKdFK_L54,8960
 vellum/workflows/exceptions.py,sha256=NiBiR3ggfmPxBVqD-H1SqmjI-7mIn0EStSN1BqApvCM,1213
 vellum/workflows/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/expressions/accessor.py,sha256=3lu1-_-dBfZdJvtX-q66jbmRAZtqIfdsh_3_JNuzg1E,4462
@@ -1888,9 +1888,11 @@ vellum/workflows/nodes/displayable/tool_calling_node/tests/__init__.py,sha256=47
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_composio_service.py,sha256=in1fbEz5x1tx3uKv9YXdvOncsHucNL8Ro6Go7lBuuOQ,8962
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=GZoeybB9uM7ai8sBLAtUMHrMVgh-WrJDWrKZci6feDs,11892
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=SIu5GCj4tIE4fz-cAcdULtQfqZIhrcc3Doo6TWLXBws,8804
-vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=7pM6MH3Z7r0k7Kpr3d-26QXUo_4GrxLflKwFTxRPREY,22844
+vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=ACEfl2pY65sO0DaMYxuecx2Kxg32HpSh7XXpp8U1J84,23459
 vellum/workflows/nodes/displayable/web_search_node/__init__.py,sha256=8FOnEP-n-U68cvxTlJW9wphIAGHq5aqjzLM-DoSSXnU,61
 vellum/workflows/nodes/displayable/web_search_node/node.py,sha256=NQYux2bOtuBF5E4tn-fXi5y3btURPRrNqMSM9MAZYI4,5091
+vellum/workflows/nodes/displayable/web_search_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/workflows/nodes/displayable/web_search_node/tests/test_node.py,sha256=H3titxCYFsfIJ3EDeRL6Pe9I-tdKMRt1axOwb2qIw6U,10983
 vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrraiBHDLKTlnBa51ZiE,284
 vellum/workflows/nodes/experimental/__init__.py,sha256=jCQgvZEknXKfuNhGSOou4XPfrPqZ1_XBj5F0n0fgiWM,106
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
@@ -1968,8 +1970,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=ptMntHzVyy8ZuzNgeTuk7hREgKQ5UBdgq8VJFSGaW4Y,20832
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.3.0.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.3.0.dist-info/METADATA,sha256=9uebeUcPKeXDi69pDtSoKp_lhlFi_rf49wUKY8fR9S4,5547
-vellum_ai-1.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.3.0.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-1.3.0.dist-info/RECORD,,
+vellum_ai-1.3.1.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.3.1.dist-info/METADATA,sha256=8eP8UQcNY66V3X1QK8GmDgvQnyi_hHztrZQNUMTCT1M,5547
+vellum_ai-1.3.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.3.1.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-1.3.1.dist-info/RECORD,,

vellum_ee/workflows/display/utils/events.py

@@ -26,6 +26,9 @@ def _should_mark_workflow_dynamic(event: WorkflowExecutionInitiatedEvent) -> boo
 
 
 def event_enricher(event: WorkflowExecutionInitiatedEvent) -> WorkflowExecutionInitiatedEvent:
+    if event.name != "workflow.execution.initiated":
+        return event
+
     workflow_definition = event.body.workflow_definition
     workflow_display = get_workflow_display(
         workflow_class=workflow_definition,