vellum-ai 0.12.8__tar.gz → 0.12.11__tar.gz

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/PKG-INFO

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

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/ee/vellum_cli/tests/test_push.py

@@ -8,7 +8,7 @@ from uuid import uuid4
 from click.testing import CliRunner
 
 from vellum.client.types.workflow_push_response import WorkflowPushResponse
-from vellum.evaluations.utils.uuid import is_valid_uuid
+from vellum.utils.uuid import is_valid_uuid
 from vellum_cli import main as cli_main
 
 

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/ee/vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -61,6 +61,11 @@ class BaseInlineSubworkflowNodeDisplay(
         display_context: WorkflowDisplayContext,
     ) -> Tuple[List[NodeInput], List[VellumVariable]]:
         subworkflow_inputs = raise_if_descriptor(node.subworkflow_inputs)
+        subworkflow_entries = (
+            [(variable_name, variable_value) for variable_name, variable_value in subworkflow_inputs.items()]
+            if isinstance(subworkflow_inputs, dict)
+            else [(variable_ref.name, variable_value) for variable_ref, variable_value in subworkflow_inputs]
+        )
         node_inputs = [
             create_node_input(
                 node_id=node_id,
@@ -69,7 +74,7 @@ class BaseInlineSubworkflowNodeDisplay(
                 display_context=display_context,
                 input_id=self.workflow_input_ids_by_name.get(variable_name),
             )
-            for variable_name, variable_value in subworkflow_inputs.items()
+            for variable_name, variable_value in subworkflow_entries
         ]
         node_inputs_by_key = {node_input.key: node_input for node_input in node_inputs}
         workflow_inputs = [

vellum_ai-0.12.11/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py

@@ -0,0 +1,207 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_templating_node.workflow_with_json_input import BasicTemplatingNodeWorkflowWithJson
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a vellum templating node",
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicTemplatingNodeWorkflowWithJson
+    )
+
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+    assert input_variables == [
+        {
+            "id": "f4435f88-703f-40e5-9197-d39b0e43ab72",
+            "key": "info",
+            "type": "JSON",
+            "default": None,
+            "required": True,
+            "extensions": {"color": None},
+        }
+    ]
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert not DeepDiff(
+        [{"id": "62ec9b08-6437-4f8d-bc20-983d317bc348", "key": "result", "type": "JSON"}],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert workflow_raw_data.keys() == {"edges", "nodes", "display_data", "definition"}
+    assert len(workflow_raw_data["edges"]) == 2
+    assert len(workflow_raw_data["nodes"]) == 3
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "09579c0a-acbf-4e04-8724-2230a8aa6534",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "34069190-0942-4e0c-8700-b33b9dea4ea0"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "definition": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []},
+    }
+
+    templating_node = workflow_raw_data["nodes"][1]
+    assert not DeepDiff(
+        {
+            "id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+            "type": "TEMPLATING",
+            "inputs": [
+                {
+                    "id": "7c775379-d589-4d79-b876-dcd224d72966",
+                    "key": "template",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "CONSTANT_VALUE",
+                                "data": {"type": "STRING", "value": "The meaning of {{ info }} is not known"},
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                },
+                {
+                    "id": "bb712499-4265-4d71-bc14-0c3d8ca6a7de",
+                    "key": "info",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "INPUT_VARIABLE",
+                                "data": {"input_variable_id": "f4435f88-703f-40e5-9197-d39b0e43ab72"},
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                },
+            ],
+            "data": {
+                "label": "Example Templating Node",
+                "output_id": "6834cae4-8173-4fa6-88f7-bc09d335bdd1",
+                "error_output_id": None,
+                "source_handle_id": "39317827-df43-4f5a-bfbc-20bffc839748",
+                "target_handle_id": "58427684-3848-498a-8299-c6b0fc70265d",
+                "template_node_input_id": "7c775379-d589-4d79-b876-dcd224d72966",
+                "output_type": "JSON",
+            },
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "ExampleTemplatingNode",
+                "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
+                "bases": [
+                    {
+                        "name": "TemplatingNode",
+                        "module": ["vellum", "workflows", "nodes", "core", "templating_node", "node"],
+                    }
+                ],
+            },
+        },
+        templating_node,
+    )
+
+    final_output_node = workflow_raw_data["nodes"][-1]
+    assert not DeepDiff(
+        {
+            "id": "9f75228b-1d5b-4c30-a581-6087e6a1b738",
+            "type": "TERMINAL",
+            "data": {
+                "label": "Final Output",
+                "name": "result",
+                "target_handle_id": "16ba108e-61a8-4338-8a5b-4f1278d7fd7b",
+                "output_id": "62ec9b08-6437-4f8d-bc20-983d317bc348",
+                "output_type": "JSON",
+                "node_input_id": "310072db-6d07-4d29-8e5c-9c6909300925",
+            },
+            "inputs": [
+                {
+                    "id": "310072db-6d07-4d29-8e5c-9c6909300925",
+                    "key": "node_input",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "NODE_OUTPUT",
+                                "data": {
+                                    "node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                                    "output_id": "6834cae4-8173-4fa6-88f7-bc09d335bdd1",
+                                },
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                }
+            ],
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "FinalOutputNode",
+                "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+                "bases": [
+                    {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []}
+                ],
+            },
+        },
+        final_output_node,
+        ignore_order=True,
+    )
+
+    # AND each edge should be serialized correctly
+    serialized_edges = workflow_raw_data["edges"]
+    assert not DeepDiff(
+        [
+            {
+                "id": "9f753b40-68de-4186-838e-806a14853935",
+                "source_node_id": "09579c0a-acbf-4e04-8724-2230a8aa6534",
+                "source_handle_id": "34069190-0942-4e0c-8700-b33b9dea4ea0",
+                "target_node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                "target_handle_id": "58427684-3848-498a-8299-c6b0fc70265d",
+                "type": "DEFAULT",
+            },
+            {
+                "id": "00cbff5c-5cce-4ef4-81b2-1a11d9b42597",
+                "source_node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                "source_handle_id": "39317827-df43-4f5a-bfbc-20bffc839748",
+                "target_node_id": "9f75228b-1d5b-4c30-a581-6087e6a1b738",
+                "target_handle_id": "16ba108e-61a8-4338-8a5b-4f1278d7fd7b",
+                "type": "DEFAULT",
+            },
+        ],
+        serialized_edges,
+        ignore_order=True,
+    )
+
+    # AND the display data should be what we expect
+    display_data = workflow_raw_data["display_data"]
+    assert display_data == {
+        "viewport": {
+            "x": 0.0,
+            "y": 0.0,
+            "zoom": 1.0,
+        }
+    }
+
+    # AND the definition should be what we expect
+    definition = workflow_raw_data["definition"]
+    assert definition == {
+        "name": "BasicTemplatingNodeWorkflowWithJson",
+        "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
+    }

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.12.8"
+version = "0.12.11"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/__init__.py

@@ -120,7 +120,6 @@ from .types import (
     FolderEntityWorkflowSandbox,
     FolderEntityWorkflowSandboxData,
     FulfilledAdHocExecutePromptEvent,
-    FulfilledEnum,
     FulfilledExecutePromptEvent,
     FulfilledExecutePromptResponse,
     FulfilledExecuteWorkflowWorkflowResultEvent,
@@ -389,6 +388,7 @@ from .types import (
     TestSuiteRunExternalExecConfigData,
     TestSuiteRunExternalExecConfigDataRequest,
     TestSuiteRunExternalExecConfigRequest,
+    TestSuiteRunMetricArrayOutput,
     TestSuiteRunMetricErrorOutput,
     TestSuiteRunMetricJsonOutput,
     TestSuiteRunMetricNumberOutput,
@@ -649,7 +649,6 @@ __all__ = [
     "FolderEntityWorkflowSandboxData",
     "ForbiddenError",
     "FulfilledAdHocExecutePromptEvent",
-    "FulfilledEnum",
     "FulfilledExecutePromptEvent",
     "FulfilledExecutePromptResponse",
     "FulfilledExecuteWorkflowWorkflowResultEvent",
@@ -922,6 +921,7 @@ __all__ = [
     "TestSuiteRunExternalExecConfigData",
     "TestSuiteRunExternalExecConfigDataRequest",
     "TestSuiteRunExternalExecConfigRequest",
+    "TestSuiteRunMetricArrayOutput",
     "TestSuiteRunMetricErrorOutput",
     "TestSuiteRunMetricJsonOutput",
     "TestSuiteRunMetricNumberOutput",

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/client/__init__.py

@@ -1079,6 +1079,7 @@ class Vellum:
         index_id: typing.Optional[str] = OMIT,
         index_name: typing.Optional[str] = OMIT,
         options: typing.Optional[SearchRequestOptionsRequest] = OMIT,
+        document_index: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> SearchResponse:
         """
@@ -1090,14 +1091,17 @@ class Vellum:
             The query to search for.
 
         index_id : typing.Optional[str]
-            The ID of the index to search against. Must provide either this or index_name.
+            The ID of the index to search against. Must provide either this, index_name or document_index.
 
         index_name : typing.Optional[str]
-            The name of the index to search against. Must provide either this or index_id.
+            The name of the index to search against. Must provide either this, index_id or document_index.
 
         options : typing.Optional[SearchRequestOptionsRequest]
             Configuration options for the search.
 
+        document_index : typing.Optional[str]
+            Either the index name or index ID to search against. Must provide either this, index_id or index_name.
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -1128,6 +1132,7 @@ class Vellum:
                 "options": convert_and_respect_annotation_metadata(
                     object_=options, annotation=SearchRequestOptionsRequest, direction="write"
                 ),
+                "document_index": document_index,
             },
             request_options=request_options,
             omit=OMIT,
@@ -2395,6 +2400,7 @@ class AsyncVellum:
         index_id: typing.Optional[str] = OMIT,
         index_name: typing.Optional[str] = OMIT,
         options: typing.Optional[SearchRequestOptionsRequest] = OMIT,
+        document_index: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> SearchResponse:
         """
@@ -2406,14 +2412,17 @@ class AsyncVellum:
             The query to search for.
 
         index_id : typing.Optional[str]
-            The ID of the index to search against. Must provide either this or index_name.
+            The ID of the index to search against. Must provide either this, index_name or document_index.
 
         index_name : typing.Optional[str]
-            The name of the index to search against. Must provide either this or index_id.
+            The name of the index to search against. Must provide either this, index_id or document_index.
 
         options : typing.Optional[SearchRequestOptionsRequest]
             Configuration options for the search.
 
+        document_index : typing.Optional[str]
+            Either the index name or index ID to search against. Must provide either this, index_id or index_name.
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -2452,6 +2461,7 @@ class AsyncVellum:
                 "options": convert_and_respect_annotation_metadata(
                     object_=options, annotation=SearchRequestOptionsRequest, direction="write"
                 ),
+                "document_index": document_index,
             },
             request_options=request_options,
             omit=OMIT,

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/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.12.8",
+            "X-Fern-SDK-Version": "0.12.11",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/client/types/__init__.py

@@ -127,7 +127,6 @@ from .folder_entity_test_suite_data import FolderEntityTestSuiteData
 from .folder_entity_workflow_sandbox import FolderEntityWorkflowSandbox
 from .folder_entity_workflow_sandbox_data import FolderEntityWorkflowSandboxData
 from .fulfilled_ad_hoc_execute_prompt_event import FulfilledAdHocExecutePromptEvent
-from .fulfilled_enum import FulfilledEnum
 from .fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
 from .fulfilled_execute_prompt_response import FulfilledExecutePromptResponse
 from .fulfilled_execute_workflow_workflow_result_event import FulfilledExecuteWorkflowWorkflowResultEvent
@@ -402,6 +401,7 @@ from .test_suite_run_external_exec_config import TestSuiteRunExternalExecConfig
 from .test_suite_run_external_exec_config_data import TestSuiteRunExternalExecConfigData
 from .test_suite_run_external_exec_config_data_request import TestSuiteRunExternalExecConfigDataRequest
 from .test_suite_run_external_exec_config_request import TestSuiteRunExternalExecConfigRequest
+from .test_suite_run_metric_array_output import TestSuiteRunMetricArrayOutput
 from .test_suite_run_metric_error_output import TestSuiteRunMetricErrorOutput
 from .test_suite_run_metric_json_output import TestSuiteRunMetricJsonOutput
 from .test_suite_run_metric_number_output import TestSuiteRunMetricNumberOutput
@@ -641,7 +641,6 @@ __all__ = [
     "FolderEntityWorkflowSandbox",
     "FolderEntityWorkflowSandboxData",
     "FulfilledAdHocExecutePromptEvent",
-    "FulfilledEnum",
     "FulfilledExecutePromptEvent",
     "FulfilledExecutePromptResponse",
     "FulfilledExecuteWorkflowWorkflowResultEvent",
@@ -910,6 +909,7 @@ __all__ = [
     "TestSuiteRunExternalExecConfigData",
     "TestSuiteRunExternalExecConfigDataRequest",
     "TestSuiteRunExternalExecConfigRequest",
+    "TestSuiteRunMetricArrayOutput",
     "TestSuiteRunMetricErrorOutput",
     "TestSuiteRunMetricJsonOutput",
     "TestSuiteRunMetricNumberOutput",

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/client/types/function_call.py

@@ -2,7 +2,6 @@
 
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
-from .fulfilled_enum import FulfilledEnum
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -15,7 +14,6 @@ class FunctionCall(UniversalBaseModel):
     arguments: typing.Dict[str, typing.Optional[typing.Any]]
     id: typing.Optional[str] = None
     name: str
-    state: typing.Optional[FulfilledEnum] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/client/types/function_call_request.py

@@ -2,7 +2,6 @@
 
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
-from .fulfilled_enum import FulfilledEnum
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -15,7 +14,6 @@ class FunctionCallRequest(UniversalBaseModel):
     arguments: typing.Dict[str, typing.Optional[typing.Any]]
     id: typing.Optional[str] = None
     name: str
-    state: typing.Optional[FulfilledEnum] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/client/types/metric_definition_execution.py

@@ -1,10 +1,13 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from __future__ import annotations
 from ..core.pydantic_utilities import UniversalBaseModel
+from .array_vellum_value import ArrayVellumValue
 import typing
 from .test_suite_run_metric_output import TestSuiteRunMetricOutput
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
+from ..core.pydantic_utilities import update_forward_refs
 
 
 class MetricDefinitionExecution(UniversalBaseModel):
@@ -18,3 +21,6 @@ class MetricDefinitionExecution(UniversalBaseModel):
             frozen = True
             smart_union = True
             extra = pydantic.Extra.allow
+
+
+update_forward_refs(ArrayVellumValue, MetricDefinitionExecution=MetricDefinitionExecution)

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/client/types/test_suite_run_execution_metric_result.py

@@ -1,11 +1,14 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from __future__ import annotations
 from ..core.pydantic_utilities import UniversalBaseModel
+from .array_vellum_value import ArrayVellumValue
 import typing
 from .test_suite_run_metric_output import TestSuiteRunMetricOutput
 from .test_suite_run_execution_metric_definition import TestSuiteRunExecutionMetricDefinition
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
+from ..core.pydantic_utilities import update_forward_refs
 
 
 class TestSuiteRunExecutionMetricResult(UniversalBaseModel):
@@ -22,3 +25,6 @@ class TestSuiteRunExecutionMetricResult(UniversalBaseModel):
             frozen = True
             smart_union = True
             extra = pydantic.Extra.allow
+
+
+update_forward_refs(ArrayVellumValue, TestSuiteRunExecutionMetricResult=TestSuiteRunExecutionMetricResult)

vellum_ai-0.12.11/src/vellum/client/types/test_suite_run_metric_array_output.py

@@ -0,0 +1,32 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+from ..core.pydantic_utilities import UniversalBaseModel
+from .array_vellum_value import ArrayVellumValue
+import typing
+from .vellum_value import VellumValue
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+from ..core.pydantic_utilities import update_forward_refs
+
+
+class TestSuiteRunMetricArrayOutput(UniversalBaseModel):
+    """
+    Output for a test suite run metric that is of type ARRAY
+    """
+
+    value: typing.Optional[typing.List[VellumValue]] = None
+    type: typing.Literal["ARRAY"] = "ARRAY"
+    name: str
+
+    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
+
+
+update_forward_refs(ArrayVellumValue, TestSuiteRunMetricArrayOutput=TestSuiteRunMetricArrayOutput)

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/client/types/test_suite_run_metric_output.py

@@ -5,10 +5,12 @@ from .test_suite_run_metric_string_output import TestSuiteRunMetricStringOutput
 from .test_suite_run_metric_number_output import TestSuiteRunMetricNumberOutput
 from .test_suite_run_metric_json_output import TestSuiteRunMetricJsonOutput
 from .test_suite_run_metric_error_output import TestSuiteRunMetricErrorOutput
+from .test_suite_run_metric_array_output import TestSuiteRunMetricArrayOutput
 
 TestSuiteRunMetricOutput = typing.Union[
     TestSuiteRunMetricStringOutput,
     TestSuiteRunMetricNumberOutput,
     TestSuiteRunMetricJsonOutput,
     TestSuiteRunMetricErrorOutput,
+    TestSuiteRunMetricArrayOutput,
 ]

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/evaluations/resources.py

@@ -12,7 +12,6 @@ from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAUL
 from vellum.evaluations.exceptions import TestSuiteRunResultsException
 from vellum.evaluations.utils.env import get_api_key
 from vellum.evaluations.utils.paginator import PaginatedResults, get_all_results
-from vellum.evaluations.utils.uuid import is_valid_uuid
 from vellum.types import (
     ExternalTestCaseExecutionRequest,
     NamedTestCaseVariableValueRequest,
@@ -24,6 +23,7 @@ from vellum.types import (
     TestSuiteRunState,
 )
 from vellum.utils.typing import cast_not_optional
+from vellum.utils.uuid import is_valid_uuid
 
 logger = logging.getLogger(__name__)
 

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/prompts/blocks/compilation.py

@@ -104,16 +104,16 @@ def compile_prompt_blocks(
                 chat_message_blocks = _compile_chat_messages_as_prompt_blocks(compiled_input.value)
                 compiled_blocks.extend(chat_message_blocks)
             else:
-                raise ValueError(f"Invalid input type for variable block: {compiled_input.type}")
+                raise PromptCompilationError(f"Invalid input type for variable block: {compiled_input.type}")
 
         elif block.block_type == "RICH_TEXT":
             value_block = _compile_rich_text_block_as_value_block(block=block, inputs=sanitized_inputs)
             compiled_blocks.append(value_block)
 
         elif block.block_type == "FUNCTION_DEFINITION":
-            raise ValueError("Function definitions shouldn't go through compilation process")
+            raise PromptCompilationError("Function definitions shouldn't go through compilation process")
         else:
-            raise ValueError(f"Unknown block_type: {block.block_type}")
+            raise PromptCompilationError(f"Unknown block_type: {block.block_type}")
 
     return compiled_blocks
 
@@ -172,7 +172,7 @@ def _compile_rich_text_block_as_value_block(
                     f"Input variable '{child_block.input_variable}' must be of type STRING or JSON"
                 )
         else:
-            raise ValueError(f"Invalid child block_type for RICH_TEXT: {child_block.block_type}")
+            raise PromptCompilationError(f"Invalid child block_type for RICH_TEXT: {child_block.block_type}")
 
     return CompiledValuePromptBlock(content=StringVellumValue(value=value), cache_config=block.cache_config)
 

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

vellum_ai-0.12.11/src/vellum/workflows/nodes/bases/__init__.py

@@ -0,0 +1,5 @@
+from .base import BaseNode
+
+__all__ = [
+    "BaseNode",
+]

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/workflows/nodes/bases/base.py

@@ -344,8 +344,8 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
         all_inputs = {}
         for key, value in inputs.items():
             path_parts = key.split(".")
-            node_attribute_discriptor = getattr(self.__class__, path_parts[0])
-            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_discriptor)
+            node_attribute_descriptor = getattr(self.__class__, path_parts[0])
+            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_descriptor)
             all_inputs[inputs_key] = value
 
         self._inputs = MappingProxyType(all_inputs)
@@ -355,7 +355,3 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
     def __repr__(self) -> str:
         return str(self.__class__)
-
-
-class MyNode2(BaseNode):
-    pass

{vellum_ai-0.12.8 → vellum_ai-0.12.11}/src/vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -1,12 +1,14 @@
-from typing import TYPE_CHECKING, Generic, Iterator, Optional, Set, Type, TypeVar
+from typing import TYPE_CHECKING, ClassVar, Generic, Iterator, Optional, Set, Type, TypeVar, Union
 
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.bases.base_subworkflow_node import BaseSubworkflowNode
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType, WorkflowInputsType
 
 if TYPE_CHECKING:
@@ -15,7 +17,7 @@ if TYPE_CHECKING:
 InnerStateType = TypeVar("InnerStateType", bound=BaseState)
 
 
-class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
+class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
     """
     Used to execute a Subworkflow defined inline.
 
@@ -24,14 +26,13 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
     """
 
     subworkflow: Type["BaseWorkflow[WorkflowInputsType, InnerStateType]"]
+    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs]] = {}
 
     def run(self) -> Iterator[BaseOutput]:
         with execution_context(parent_context=get_parent_context() or self._context.parent_context):
             subworkflow = self.subworkflow(
                 parent_state=self.state,
-                context=WorkflowContext(
-                    _vellum_client=self._context._vellum_client,
-                ),
+                context=WorkflowContext(vellum_client=self._context.vellum_client),
             )
             subworkflow_stream = subworkflow.stream(
                 inputs=self._compile_subworkflow_inputs(),
@@ -68,4 +69,9 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
 
     def _compile_subworkflow_inputs(self) -> WorkflowInputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        return inputs_class(**self.subworkflow_inputs)
+        if isinstance(self.subworkflow_inputs, dict):
+            return inputs_class(**self.subworkflow_inputs)
+        elif isinstance(self.subworkflow_inputs, inputs_class):
+            return self.subworkflow_inputs
+        else:
+            raise ValueError(f"Invalid subworkflow inputs type: {type(self.subworkflow_inputs)}")