vellum-ai 0.14.68__tar.gz → 0.14.69__tar.gz

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/PKG-INFO

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

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -18,10 +18,9 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
 class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
-    __serializable_inputs__ = {InlinePromptNode.prompt_inputs}
+    __serializable_inputs__ = {InlinePromptNode.prompt_inputs, InlinePromptNode.functions}
     __unserializable_attributes__ = {
         InlinePromptNode.blocks,
-        InlinePromptNode.functions,
         InlinePromptNode.parameters,
         InlinePromptNode.settings,
         InlinePromptNode.expand_meta,
@@ -48,9 +47,10 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         blocks: list = [
             self._generate_prompt_block(block, input_variable_id_by_name, [i]) for i, block in enumerate(node_blocks)
         ]
+
         functions = (
             [self._generate_function_tools(function, i) for i, function in enumerate(function_definitions)]
-            if function_definitions
+            if isinstance(function_definitions, list)
             else []
         )
         blocks.extend(functions)

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_prompt_node_serialization.py

@@ -1,5 +1,11 @@
 from deepdiff import DeepDiff
 
+from vellum import ChatMessagePromptBlock, FunctionDefinition, JinjaPromptBlock
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import InlinePromptNode
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state import BaseState
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 from tests.workflows.basic_inline_prompt_node_with_functions.workflow import BasicInlinePromptWithFunctionsWorkflow
@@ -185,6 +191,27 @@ def test_serialize_workflow():
                         ],
                     },
                 },
+                {
+                    "id": "8107682b-2ca0-4967-88f9-284455936575",
+                    "name": "functions",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "JSON",
+                            "value": [
+                                {
+                                    "state": None,
+                                    "cache_config": None,
+                                    "name": "favorite_noun",
+                                    "description": "Returns the favorite noun of the user",
+                                    "parameters": {},
+                                    "forced": None,
+                                    "strict": None,
+                                }
+                            ],
+                        },
+                    },
+                },
             ],
         },
         prompt_node,
@@ -274,3 +301,57 @@ def test_serialize_workflow():
         "name": "BasicInlinePromptWithFunctionsWorkflow",
         "module": ["tests", "workflows", "basic_inline_prompt_node_with_functions", "workflow"],
     }
+
+
+def test_serialize_workflow_with_descriptor_functions():
+    """Test that serialization handles BaseDescriptor instances in functions list."""
+
+    class TestInputs(BaseInputs):
+        noun: str
+
+    class MockMCPClientNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            tools: list[FunctionDefinition]
+
+    class TestInlinePromptNodeWithDescriptorFunctions(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = [
+            ChatMessagePromptBlock(
+                chat_role="SYSTEM",
+                blocks=[JinjaPromptBlock(template="Test {{noun}}")],
+            ),
+        ]
+        prompt_inputs = {"noun": TestInputs.noun}
+        functions = MockMCPClientNode.Outputs.tools  # type: ignore
+
+    class TestWorkflow(BaseWorkflow[TestInputs, BaseState]):
+        graph = MockMCPClientNode >> TestInlinePromptNodeWithDescriptorFunctions
+
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized: dict = workflow_display.serialize()
+
+    prompt_nodes = [node for node in serialized["workflow_raw_data"]["nodes"] if node["type"] == "PROMPT"]
+    assert len(prompt_nodes) == 1
+
+    prompt_node = prompt_nodes[0]
+    assert isinstance(prompt_node, dict)
+    blocks = prompt_node["data"]["exec_config"]["prompt_template_block_data"]["blocks"]
+    assert isinstance(blocks, list)
+
+    function_blocks = [
+        block for block in blocks if isinstance(block, dict) and block.get("block_type") == "FUNCTION_DEFINITION"
+    ]
+    assert len(function_blocks) == 0  # We don't serialize the legacy function blocks when dynamic
+
+    assert "attributes" in prompt_node
+    assert isinstance(prompt_node["attributes"], list)
+    functions_attr = next(
+        (attr for attr in prompt_node["attributes"] if isinstance(attr, dict) and attr["name"] == "functions"), None
+    )
+    assert isinstance(functions_attr, dict), "functions attribute should be present in serialized attributes"
+
+    assert functions_attr["value"] == {
+        "node_id": "cb1186e0-8ff1-4145-823e-96b3fc05a39a",
+        "node_output_id": "470fadb9-b8b5-477e-a502-5209d398bcf9",
+        "type": "NODE_OUTPUT",
+    }

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/pyproject.toml

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

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/src/vellum/__init__.py

@@ -123,6 +123,8 @@ from .types import (
     ExternalInputDescriptor,
     ExternalTestCaseExecution,
     ExternalTestCaseExecutionRequest,
+    FastEmbedVectorizerBaaiBgeSmallEnV15,
+    FastEmbedVectorizerBaaiBgeSmallEnV15Request,
     FinishReasonEnum,
     FolderEntity,
     FolderEntityDocumentIndex,
@@ -750,6 +752,8 @@ __all__ = [
     "ExternalInputDescriptor",
     "ExternalTestCaseExecution",
     "ExternalTestCaseExecutionRequest",
+    "FastEmbedVectorizerBaaiBgeSmallEnV15",
+    "FastEmbedVectorizerBaaiBgeSmallEnV15Request",
     "FinishReasonEnum",
     "FolderEntitiesListRequestEntityStatus",
     "FolderEntity",

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/src/vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.68",
+            "X-Fern-SDK-Version": "0.14.69",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/src/vellum/client/types/__init__.py

@@ -127,6 +127,8 @@ from .execution_vellum_value import ExecutionVellumValue
 from .external_input_descriptor import ExternalInputDescriptor
 from .external_test_case_execution import ExternalTestCaseExecution
 from .external_test_case_execution_request import ExternalTestCaseExecutionRequest
+from .fast_embed_vectorizer_baai_bge_small_en_v_15 import FastEmbedVectorizerBaaiBgeSmallEnV15
+from .fast_embed_vectorizer_baai_bge_small_en_v_15_request import FastEmbedVectorizerBaaiBgeSmallEnV15Request
 from .finish_reason_enum import FinishReasonEnum
 from .folder_entity import FolderEntity
 from .folder_entity_document_index import FolderEntityDocumentIndex
@@ -737,6 +739,8 @@ __all__ = [
     "ExternalInputDescriptor",
     "ExternalTestCaseExecution",
     "ExternalTestCaseExecutionRequest",
+    "FastEmbedVectorizerBaaiBgeSmallEnV15",
+    "FastEmbedVectorizerBaaiBgeSmallEnV15Request",
     "FinishReasonEnum",
     "FolderEntity",
     "FolderEntityDocumentIndex",

vellum_ai-0.14.69/src/vellum/client/types/fast_embed_vectorizer_baai_bge_small_en_v_15.py

@@ -0,0 +1,23 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class FastEmbedVectorizerBaaiBgeSmallEnV15(UniversalBaseModel):
+    """
+    FastEmbed vectorizer for BAAI/bge-small-en-v1.5.
+    """
+
+    model_name: typing.Literal["BAAI/bge-small-en-v1.5"] = "BAAI/bge-small-en-v1.5"
+
+    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_ai-0.14.69/src/vellum/client/types/fast_embed_vectorizer_baai_bge_small_en_v_15_request.py

@@ -0,0 +1,23 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class FastEmbedVectorizerBaaiBgeSmallEnV15Request(UniversalBaseModel):
+    """
+    FastEmbed vectorizer for BAAI/bge-small-en-v1.5.
+    """
+
+    model_name: typing.Literal["BAAI/bge-small-en-v1.5"] = "BAAI/bge-small-en-v1.5"
+
+    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_ai-0.14.68 → vellum_ai-0.14.69}/src/vellum/client/types/folder_entity_document_index_data.py

@@ -3,6 +3,7 @@
 from ..core.pydantic_utilities import UniversalBaseModel
 import datetime as dt
 from .entity_status import EntityStatus
+from .document_index_indexing_config import DocumentIndexIndexingConfig
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import typing
 import pydantic
@@ -14,6 +15,7 @@ class FolderEntityDocumentIndexData(UniversalBaseModel):
     created: dt.datetime
     modified: dt.datetime
     status: EntityStatus
+    indexing_config: DocumentIndexIndexingConfig
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/src/vellum/client/types/indexing_config_vectorizer.py

@@ -16,6 +16,7 @@ from .google_vertex_ai_vectorizer_text_embedding_004 import GoogleVertexAiVector
 from .google_vertex_ai_vectorizer_text_multilingual_embedding_002 import (
     GoogleVertexAiVectorizerTextMultilingualEmbedding002,
 )
+from .fast_embed_vectorizer_baai_bge_small_en_v_15 import FastEmbedVectorizerBaaiBgeSmallEnV15
 
 IndexingConfigVectorizer = typing.Union[
     OpenAiVectorizerTextEmbedding3Small,
@@ -27,4 +28,5 @@ IndexingConfigVectorizer = typing.Union[
     HkunlpInstructorXlVectorizer,
     GoogleVertexAiVectorizerTextEmbedding004,
     GoogleVertexAiVectorizerTextMultilingualEmbedding002,
+    FastEmbedVectorizerBaaiBgeSmallEnV15,
 ]

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/src/vellum/client/types/indexing_config_vectorizer_request.py

@@ -16,6 +16,7 @@ from .google_vertex_ai_vectorizer_text_embedding_004_request import GoogleVertex
 from .google_vertex_ai_vectorizer_text_multilingual_embedding_002_request import (
     GoogleVertexAiVectorizerTextMultilingualEmbedding002Request,
 )
+from .fast_embed_vectorizer_baai_bge_small_en_v_15_request import FastEmbedVectorizerBaaiBgeSmallEnV15Request
 
 IndexingConfigVectorizerRequest = typing.Union[
     OpenAiVectorizerTextEmbedding3SmallRequest,
@@ -27,4 +28,5 @@ IndexingConfigVectorizerRequest = typing.Union[
     HkunlpInstructorXlVectorizerRequest,
     GoogleVertexAiVectorizerTextEmbedding004Request,
     GoogleVertexAiVectorizerTextMultilingualEmbedding002Request,
+    FastEmbedVectorizerBaaiBgeSmallEnV15Request,
 ]

vellum_ai-0.14.69/src/vellum/types/fast_embed_vectorizer_baai_bge_small_en_v_15.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.fast_embed_vectorizer_baai_bge_small_en_v_15 import *

vellum_ai-0.14.69/src/vellum/types/fast_embed_vectorizer_baai_bge_small_en_v_15_request.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.fast_embed_vectorizer_baai_bge_small_en_v_15_request import *

{vellum_ai-0.14.68 → vellum_ai-0.14.69}/src/vellum/workflows/nodes/displayable/bases/search_node.py

@@ -106,11 +106,23 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
                 message=f"Document Index '{self.document_index}' not found",
                 code=WorkflowErrorCode.INVALID_INPUTS,
             )
-        except ApiError:
+        except ApiError as e:
+            if e.status_code and e.status_code == 403 and isinstance(e.body, dict):
+                raise NodeException(
+                    message=e.body.get("detail", "Provider credentials is missing or unavailable"),
+                    code=WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+                )
+            elif e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
+                raise NodeException(
+                    message=e.body.get(
+                        "detail", f"An error occurred while searching against Document Index '{self.document_index}'"
+                    ),
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                ) from e
             raise NodeException(
-                message=f"An error occurred while searching against Document Index '{self.document_index}'",  # noqa: E501
+                message=f"An error occurred while searching against Document Index '{self.document_index}'",
                 code=WorkflowErrorCode.INTERNAL_ERROR,
-            )
+            ) from e
 
     def _get_options_request(self) -> SearchRequestOptionsRequest:
         return SearchRequestOptionsRequest(

vellum_ai-0.14.69/src/vellum/workflows/nodes/displayable/tests/test_search_node_error_handling.py

@@ -0,0 +1,215 @@
+import pytest
+
+from vellum.client.core.api_error import ApiError
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes.displayable.search_node import SearchNode as BaseSearchNode
+from vellum.workflows.state import BaseState
+from vellum.workflows.state.base import StateMeta
+
+
+def test_search_node_handles_403_error(vellum_client):
+    """Test that SearchNode properly handles 403 API errors with user-facing messages."""
+
+    class Inputs(BaseInputs):
+        query: str
+        document_index: str
+
+    class State(BaseState):
+        pass
+
+    class SearchNode(BaseSearchNode):
+        query = Inputs.query
+        document_index = Inputs.document_index
+
+    vellum_client.search.side_effect = ApiError(
+        status_code=403, body={"detail": "Provider credentials is missing or unavailable"}
+    )
+
+    node = SearchNode(
+        state=State(
+            meta=StateMeta(
+                workflow_inputs=Inputs(
+                    query="test query",
+                    document_index="test-index",
+                )
+            ),
+        )
+    )
+
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE
+    assert exc_info.value.message == "Provider credentials is missing or unavailable"
+
+
+def test_search_node_handles_403_error_with_custom_detail(vellum_client):
+    """Test that SearchNode properly handles 403 API errors with custom detail message."""
+
+    class Inputs(BaseInputs):
+        query: str
+        document_index: str
+
+    class State(BaseState):
+        pass
+
+    class SearchNode(BaseSearchNode):
+        query = Inputs.query
+        document_index = Inputs.document_index
+
+    vellum_client.search.side_effect = ApiError(status_code=403, body={"detail": "Access denied to document index"})
+
+    node = SearchNode(
+        state=State(
+            meta=StateMeta(
+                workflow_inputs=Inputs(
+                    query="test query",
+                    document_index="test-index",
+                )
+            ),
+        )
+    )
+
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE
+    assert exc_info.value.message == "Access denied to document index"
+
+
+def test_search_node_handles_403_error_without_detail(vellum_client):
+    """Test that SearchNode properly handles 403 API errors without detail in body."""
+
+    class Inputs(BaseInputs):
+        query: str
+        document_index: str
+
+    class State(BaseState):
+        pass
+
+    class SearchNode(BaseSearchNode):
+        query = Inputs.query
+        document_index = Inputs.document_index
+
+    vellum_client.search.side_effect = ApiError(status_code=403, body={})
+
+    node = SearchNode(
+        state=State(
+            meta=StateMeta(
+                workflow_inputs=Inputs(
+                    query="test query",
+                    document_index="test-index",
+                )
+            ),
+        )
+    )
+
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE
+    assert exc_info.value.message == "Provider credentials is missing or unavailable"
+
+
+def test_search_node_handles_other_4xx_errors(vellum_client):
+    """Test that SearchNode properly handles other 4xx API errors."""
+
+    class Inputs(BaseInputs):
+        query: str
+        document_index: str
+
+    class State(BaseState):
+        pass
+
+    class SearchNode(BaseSearchNode):
+        query = Inputs.query
+        document_index = Inputs.document_index
+
+    vellum_client.search.side_effect = ApiError(status_code=400, body={"detail": "Invalid request parameters"})
+
+    node = SearchNode(
+        state=State(
+            meta=StateMeta(
+                workflow_inputs=Inputs(
+                    query="test query",
+                    document_index="test-index",
+                )
+            ),
+        )
+    )
+
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Invalid request parameters" in exc_info.value.message
+
+
+def test_search_node_handles_5xx_errors(vellum_client):
+    """Test that SearchNode properly handles 5xx API errors as internal errors."""
+
+    class Inputs(BaseInputs):
+        query: str
+        document_index: str
+
+    class State(BaseState):
+        pass
+
+    class SearchNode(BaseSearchNode):
+        query = Inputs.query
+        document_index = Inputs.document_index
+
+    vellum_client.search.side_effect = ApiError(status_code=500, body={"detail": "Internal server error"})
+
+    node = SearchNode(
+        state=State(
+            meta=StateMeta(
+                workflow_inputs=Inputs(
+                    query="test query",
+                    document_index="test-index",
+                )
+            ),
+        )
+    )
+
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INTERNAL_ERROR
+    assert "An error occurred while searching against Document Index 'test-index'" in exc_info.value.message
+
+
+def test_search_node_handles_api_error_without_status_code(vellum_client):
+    """Test that SearchNode properly handles API errors without status code."""
+
+    class Inputs(BaseInputs):
+        query: str
+        document_index: str
+
+    class State(BaseState):
+        pass
+
+    class SearchNode(BaseSearchNode):
+        query = Inputs.query
+        document_index = Inputs.document_index
+
+    vellum_client.search.side_effect = ApiError(status_code=None, body={"detail": "Unknown error"})
+
+    node = SearchNode(
+        state=State(
+            meta=StateMeta(
+                workflow_inputs=Inputs(
+                    query="test query",
+                    document_index="test-index",
+                )
+            ),
+        )
+    )
+
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INTERNAL_ERROR
+    assert "An error occurred while searching against Document Index 'test-index'" in exc_info.value.message