vellum-ai 1.5.6__tar.gz → 1.6.1__tar.gz

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/PKG-INFO

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

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_vellum_integration_serialization.py

@@ -63,6 +63,6 @@ def test_serialize_workflow():
     function = functions_value[0]
     assert function["type"] == "VELLUM_INTEGRATION"
     assert function["provider"] == "COMPOSIO"  # VellumIntegrationProviderType.COMPOSIO
-    assert function["integration"] == "GITHUB"
+    assert function["integration_name"] == "GITHUB"
     assert function["name"] == "create_issue"
     assert function["description"] == "Create a new issue in a GitHub repository"

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/pyproject.toml

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

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/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.5.6",
+            "User-Agent": "vellum-ai/1.6.1",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.5.6",
+            "X-Fern-SDK-Version": "1.6.1",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/composio_tool_definition.py

@@ -15,6 +15,7 @@ class ComposioToolDefinition(UniversalBaseModel):
     provider: typing.Literal["COMPOSIO"] = "COMPOSIO"
     integration: ToolDefinitionIntegration
     name: str
+    label: str
     description: str
     input_parameters: typing.Dict[str, typing.Optional[typing.Any]]
     output_parameters: typing.Dict[str, typing.Optional[typing.Any]]

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/named_test_case_audio_variable_value.py

@@ -13,7 +13,7 @@ class NamedTestCaseAudioVariableValue(UniversalBaseModel):
     """
 
     type: typing.Literal["AUDIO"] = "AUDIO"
-    value: VellumAudio
+    value: typing.Optional[VellumAudio] = None
     name: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/named_test_case_audio_variable_value_request.py

@@ -13,7 +13,7 @@ class NamedTestCaseAudioVariableValueRequest(UniversalBaseModel):
     """
 
     type: typing.Literal["AUDIO"] = "AUDIO"
-    value: VellumAudioRequest
+    value: typing.Optional[VellumAudioRequest] = None
     name: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/named_test_case_document_variable_value.py

@@ -9,7 +9,7 @@ from .vellum_document import VellumDocument
 
 class NamedTestCaseDocumentVariableValue(UniversalBaseModel):
     type: typing.Literal["DOCUMENT"] = "DOCUMENT"
-    value: VellumDocument
+    value: typing.Optional[VellumDocument] = None
     name: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/named_test_case_document_variable_value_request.py

@@ -9,7 +9,7 @@ from .vellum_document_request import VellumDocumentRequest
 
 class NamedTestCaseDocumentVariableValueRequest(UniversalBaseModel):
     type: typing.Literal["DOCUMENT"] = "DOCUMENT"
-    value: VellumDocumentRequest
+    value: typing.Optional[VellumDocumentRequest] = None
     name: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/named_test_case_image_variable_value.py

@@ -9,7 +9,7 @@ from .vellum_image import VellumImage
 
 class NamedTestCaseImageVariableValue(UniversalBaseModel):
     type: typing.Literal["IMAGE"] = "IMAGE"
-    value: VellumImage
+    value: typing.Optional[VellumImage] = None
     name: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/named_test_case_image_variable_value_request.py

@@ -9,7 +9,7 @@ from .vellum_image_request import VellumImageRequest
 
 class NamedTestCaseImageVariableValueRequest(UniversalBaseModel):
     type: typing.Literal["IMAGE"] = "IMAGE"
-    value: VellumImageRequest
+    value: typing.Optional[VellumImageRequest] = None
     name: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/named_test_case_video_variable_value.py

@@ -9,7 +9,7 @@ from .vellum_video import VellumVideo
 
 class NamedTestCaseVideoVariableValue(UniversalBaseModel):
     type: typing.Literal["VIDEO"] = "VIDEO"
-    value: VellumVideo
+    value: typing.Optional[VellumVideo] = None
     name: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/named_test_case_video_variable_value_request.py

@@ -9,7 +9,7 @@ from .vellum_video_request import VellumVideoRequest
 
 class NamedTestCaseVideoVariableValueRequest(UniversalBaseModel):
     type: typing.Literal["VIDEO"] = "VIDEO"
-    value: VellumVideoRequest
+    value: typing.Optional[VellumVideoRequest] = None
     name: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/paginated_slim_tool_definition_list.py

@@ -8,10 +8,10 @@ from .components_schemas_slim_composio_tool_definition import ComponentsSchemasS
 
 
 class PaginatedSlimToolDefinitionList(UniversalBaseModel):
-    count: typing.Optional[int] = None
+    count: int
     next: typing.Optional[str] = None
     previous: typing.Optional[str] = None
-    results: typing.Optional[typing.List[ComponentsSchemasSlimComposioToolDefinition]] = None
+    results: typing.List[ComponentsSchemasSlimComposioToolDefinition]
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/slim_composio_tool_definition.py

@@ -11,6 +11,7 @@ class SlimComposioToolDefinition(UniversalBaseModel):
     provider: typing.Literal["COMPOSIO"] = "COMPOSIO"
     integration: ToolDefinitionIntegration
     name: str
+    label: str
     description: str
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/test_case_audio_variable_value.py

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

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/test_case_document_variable_value.py

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

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/test_case_image_variable_value.py

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

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/client/types/test_case_video_variable_value.py

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

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/workflows/errors/types.py

@@ -21,6 +21,7 @@ class WorkflowErrorCode(Enum):
     INTERNAL_ERROR = "INTERNAL_ERROR"
     NODE_EXECUTION = "NODE_EXECUTION"
     PROVIDER_CREDENTIALS_UNAVAILABLE = "PROVIDER_CREDENTIALS_UNAVAILABLE"
+    INTEGRATION_CREDENTIALS_UNAVAILABLE = "INTEGRATION_CREDENTIALS_UNAVAILABLE"
     PROVIDER_ERROR = "PROVIDER_ERROR"
     USER_DEFINED_ERROR = "USER_DEFINED_ERROR"
     WORKFLOW_CANCELLED = "WORKFLOW_CANCELLED"
@@ -92,6 +93,8 @@ _WORKFLOW_ERROR_CODE_TO_VELLUM_ERROR_CODE: Dict[WorkflowErrorCode, VellumErrorCo
     WorkflowErrorCode.INTERNAL_ERROR: "INTERNAL_SERVER_ERROR",
     WorkflowErrorCode.NODE_EXECUTION: "USER_DEFINED_ERROR",
     WorkflowErrorCode.PROVIDER_ERROR: "PROVIDER_ERROR",
+    WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE: "PROVIDER_CREDENTIALS_UNAVAILABLE",
+    WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE: "PROVIDER_CREDENTIALS_UNAVAILABLE",
     WorkflowErrorCode.USER_DEFINED_ERROR: "USER_DEFINED_ERROR",
     WorkflowErrorCode.WORKFLOW_CANCELLED: "REQUEST_TIMEOUT",
 }

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/workflows/integrations/tests/test_vellum_integration_service.py

@@ -19,6 +19,7 @@ def test_vellum_integration_service_get_tool_definition_success(vellum_client):
             provider="COMPOSIO",
             name="GITHUB",
         ),
+        label="GITHUB_CREATE_AN_ISSUE",
         name="GITHUB_CREATE_AN_ISSUE",
         description="Create a new issue in a GitHub repository",
         input_parameters={
@@ -211,3 +212,86 @@ def test_vellum_integration_service_multiple_tool_executions(vellum_client):
 
     # AND the API should have been called twice
     assert mock_client.integrations.execute_integration_tool.call_count == 2
+
+
+def test_vellum_integration_service_execute_tool_structured_403_error(vellum_client):
+    """Test that structured 403 responses with integration details are properly parsed"""
+    from vellum.client.core.api_error import ApiError
+    from vellum.workflows.errors.types import WorkflowErrorCode
+
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    # Mock structured 403 response matching PR #14857 format
+    structured_error_body = {
+        "message": "You must authenticate with this integration before you can execute this tool.",
+        "integration": {
+            "id": "550e8400-e29b-41d4-a716-446655440000",
+            "provider": "COMPOSIO",
+            "name": "GITHUB",
+        },
+    }
+
+    mock_client.integrations.execute_integration_tool.side_effect = ApiError(
+        status_code=403,
+        body=structured_error_body,
+    )
+
+    service = VellumIntegrationService(client=mock_client)
+
+    # WHEN we attempt to execute a tool without credentials
+    with pytest.raises(NodeException) as exc_info:
+        service.execute_tool(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="GITHUB_CREATE_AN_ISSUE",
+            arguments={"repo": "user/repo"},
+        )
+
+    # THEN it should raise NodeException with INTEGRATION_CREDENTIALS_UNAVAILABLE code
+    assert exc_info.value.code == WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE
+
+    # AND the error message should match the backend response
+    assert "You must authenticate with this integration" in exc_info.value.message
+
+    # AND raw_data should contain integration details nested under "integration" key
+    assert exc_info.value.raw_data is not None
+    assert exc_info.value.raw_data["integration"]["id"] == "550e8400-e29b-41d4-a716-446655440000"
+    assert exc_info.value.raw_data["integration"]["name"] == "GITHUB"
+    assert exc_info.value.raw_data["integration"]["provider"] == "COMPOSIO"
+
+
+def test_vellum_integration_service_execute_tool_legacy_403_error(vellum_client):
+    """Test backward compatibility with legacy 403 responses (before PR #14857)"""
+    from vellum.client.core.api_error import ApiError
+    from vellum.workflows.errors.types import WorkflowErrorCode
+
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    # Mock legacy 403 response format (just detail field)
+    legacy_error_body = {"detail": "You do not have permission to execute this tool."}
+
+    mock_client.integrations.execute_integration_tool.side_effect = ApiError(
+        status_code=403,
+        body=legacy_error_body,
+    )
+
+    service = VellumIntegrationService(client=mock_client)
+
+    with pytest.raises(NodeException) as exc_info:
+        service.execute_tool(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="GITHUB_CREATE_AN_ISSUE",
+            arguments={"repo": "user/repo"},
+        )
+
+    # THEN it should use the generic PROVIDER_CREDENTIALS_UNAVAILABLE code
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE
+
+    # AND the message should match the legacy format
+    assert "You do not have permission" in exc_info.value.message
+
+    # AND raw_data should be None (no integration details available)
+    assert exc_info.value.raw_data is None

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/workflows/integrations/vellum_integration_service.py

@@ -1,5 +1,6 @@
 from typing import Any, Dict, Optional
 
+from vellum.client.core.api_error import ApiError
 from vellum.workflows.constants import VellumIntegrationProviderType
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -47,7 +48,7 @@ class VellumIntegrationService:
 
             return VellumIntegrationToolDetails(
                 provider=VellumIntegrationProviderType(response.provider),
-                integration=integration,
+                integration_name=integration,
                 name=response.name,
                 description=response.description,
                 parameters=response.input_parameters,
@@ -78,7 +79,8 @@ class VellumIntegrationService:
             Dict containing the execution result data
 
         Raises:
-            NodeException: If the tool execution fails
+            NodeException: If the tool execution fails, including credential errors
+                with integration details in raw_data
         """
         try:
             response = self._client.integrations.execute_integration_tool(
@@ -90,7 +92,37 @@ class VellumIntegrationService:
 
             # Return the data from the response
             return response.data
+        except ApiError as e:
+            # Handle structured 403 credential error responses
+            if e.status_code == 403 and isinstance(e.body, dict):
+                if "integration" in e.body and "message" in e.body:
+                    integration_details = e.body["integration"]
+                    error_message = e.body["message"]
+
+                    # Keep integration details nested under "integration" key to keep raw_data raw
+                    # and allow for future expansion
+                    raw_data = {
+                        "integration": integration_details,
+                    }
+
+                    raise NodeException(
+                        message=error_message,
+                        code=WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE,
+                        raw_data=raw_data,
+                    ) from e
+                else:
+                    # Fallback for generic 403 responses
+                    raise NodeException(
+                        message=e.body.get("detail", "You do not have permission to execute this tool."),
+                        code=WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+                    ) from e
+            # Generic server error
+            raise NodeException(
+                message=f"Failed to execute tool {tool_name}: {str(e)}",
+                code=WorkflowErrorCode.INTERNAL_ERROR,
+            ) from e
         except Exception as e:
+            # Catch-all for non-API errors
             error_message = f"Failed to execute tool {tool_name}: {str(e)}"
             raise NodeException(
                 message=error_message,

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -275,7 +275,7 @@ class VellumIntegrationNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         try:
             vellum_service = VellumIntegrationService()
             result = vellum_service.execute_tool(
-                integration=self.vellum_integration_tool.integration,
+                integration=self.vellum_integration_tool.integration_name,
                 provider=self.vellum_integration_tool.provider.value,
                 tool_name=self.vellum_integration_tool.name,
                 arguments=arguments,

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/workflows/ports/port.py

@@ -96,7 +96,10 @@ class Port:
             if self._condition is None:
                 return False
 
-            value = self._condition.resolve(state)
+            if isinstance(self._condition, BaseDescriptor):
+                value = self._condition.resolve(state)
+            else:
+                value = self._condition
             return bool(value)
         except InvalidExpressionException as e:
             raise NodeException(

vellum_ai-1.6.1/src/vellum/workflows/ports/tests/test_port.py

@@ -0,0 +1,45 @@
+import pytest
+from unittest.mock import Mock
+
+from vellum.workflows.ports.port import Port
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.core import ConditionType
+
+
+@pytest.mark.parametrize(
+    "condition_value,expected",
+    [
+        # Truthy values
+        (True, True),
+        (1, True),
+        ("hello", True),
+        ([1, 2, 3], True),
+        ({"key": "value"}, True),
+        (1.5, True),
+        (-1, True),
+        # Falsy values
+        (False, False),
+        (0, False),
+        ("", False),
+        ([], False),
+        ({}, False),
+        (0.0, False),
+        (None, False),
+    ],
+)
+def test_port_on_if_with_non_descriptor_values(condition_value, expected):
+    """Test that Port.on_if() correctly handles non-descriptor values."""
+
+    # Given a port with a non-descriptor value
+    port = Port.on_if(condition_value)
+
+    # Then the port properties should be correct
+    assert port._condition_type == ConditionType.IF
+    assert port._condition == condition_value
+
+    # When we resolve the condition
+    mock_state = Mock(spec=BaseState)
+    result = port.resolve_condition(mock_state)
+
+    # Then the result should be correct
+    assert result == expected

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/workflows/types/definition.py

@@ -170,7 +170,7 @@ class VellumIntegrationToolDefinition(UniversalBaseModel):
 
     # Core identification
     provider: VellumIntegrationProviderType
-    integration: str  # "GITHUB", "SLACK", etc.
+    integration_name: str  # "GITHUB", "SLACK", etc.
     name: str  # Specific action like "GITHUB_CREATE_AN_ISSUE"
 
     # Required for tool base consistency

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/workflows/types/tests/test_definition.py

@@ -155,14 +155,14 @@ def test_vellum_integration_tool_definition_creation():
     """Test that VellumIntegrationToolDefinition can be created with required fields."""
     vellum_tool = VellumIntegrationToolDefinition(
         provider=VellumIntegrationProviderType.COMPOSIO,
-        integration="GITHUB",
+        integration_name="GITHUB",
         name="create_issue",
         description="Create a new issue in a GitHub repository",
     )
 
     assert vellum_tool.type == "VELLUM_INTEGRATION"
     assert vellum_tool.provider == VellumIntegrationProviderType.COMPOSIO
-    assert vellum_tool.integration == "GITHUB"
+    assert vellum_tool.integration_name == "GITHUB"
     assert vellum_tool.name == "create_issue"
     assert vellum_tool.description == "Create a new issue in a GitHub repository"
 
@@ -171,13 +171,13 @@ def test_vellum_integration_tool_definition_with_different_provider():
     """Test VellumIntegrationToolDefinition with a different provider."""
     vellum_tool = VellumIntegrationToolDefinition(
         provider=VellumIntegrationProviderType.COMPOSIO,
-        integration="SLACK",
+        integration_name="SLACK",
         name="send_message",
         description="Send a message to a Slack channel",
     )
 
     assert vellum_tool.type == "VELLUM_INTEGRATION"
     assert vellum_tool.provider == VellumIntegrationProviderType.COMPOSIO
-    assert vellum_tool.integration == "SLACK"
+    assert vellum_tool.integration_name == "SLACK"
     assert vellum_tool.name == "send_message"
     assert vellum_tool.description == "Send a message to a Slack channel"

{vellum_ai-1.5.6 → vellum_ai-1.6.1}/src/vellum/workflows/utils/functions.py

@@ -335,7 +335,7 @@ def compile_vellum_integration_tool_definition(tool_def: VellumIntegrationToolDe
     try:
         service = VellumIntegrationService()
         tool_details = service.get_tool_definition(
-            integration=tool_def.integration,
+            integration=tool_def.integration_name,
             provider=tool_def.provider.value,
             tool_name=tool_def.name,
         )