vellum-ai 0.11.0__tar.gz → 0.11.3__tar.gz

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/PKG-INFO

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

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_cli/pull.py

@@ -19,10 +19,12 @@ def resolve_workflow_config(
     if module:
         return next((w for w in config.workflows if w.module == module), None)
     elif workflow_sandbox_id:
-        return WorkflowConfig(
+        workflow_config = WorkflowConfig(
             workflow_sandbox_id=workflow_sandbox_id,
             module=f"workflow_{workflow_sandbox_id.split('-')[0]}",
         )
+        config.workflows.append(workflow_config)
+        return workflow_config
     elif config.workflows:
         return config.workflows[0]
 

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_cli/tests/test_pull.py

@@ -1,5 +1,6 @@
 import pytest
 import io
+import json
 import os
 import tempfile
 from uuid import uuid4
@@ -113,6 +114,23 @@ def test_pull__sandbox_id_with_no_config(vellum_client):
     with open(workflow_py) as f:
         assert f.read() == "print('hello')"
 
+    # AND the vellum.lock.json file is created
+    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
+    assert os.path.exists(vellum_lock_json)
+    with open(vellum_lock_json) as f:
+        lock_data = json.loads(f.read())
+        assert lock_data == {
+            "version": "1.0",
+            "workflows": [
+                {
+                    "module": "workflow_87654321",
+                    "workflow_sandbox_id": "87654321-0000-0000-0000-000000000000",
+                    "ignore": None,
+                    "deployments": [],
+                }
+            ],
+        }
+
 
 def test_pull__sandbox_id_with_other_workflow_configured(vellum_client, mock_module):
     # GIVEN a pyproject.toml with a workflow configured

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/base.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from uuid import UUID
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 
 @dataclass
@@ -20,7 +20,6 @@ WorkflowMetaDisplayOverridesType = TypeVar("WorkflowMetaDisplayOverridesType", b
 @dataclass
 class WorkflowInputsDisplayOverrides:
     id: UUID
-    color: Optional[str] = None
 
 
 @dataclass

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/nodes/vellum/api_node.py

@@ -8,6 +8,7 @@ from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeV
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.vellum import WorkspaceSecretPointer
 
 _APINodeType = TypeVar("_APINodeType", bound=APINode)
 
@@ -79,16 +80,13 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             if authorization_type
             else None
         )
-        bearer_token_value_node_input = (
-            create_node_input(
-                node_id=node_id,
-                input_name="bearer_token_value",
-                value=bearer_token_value,
-                display_context=display_context,
-                input_id=self.bearer_token_value_input_id,
-            )
-            if bearer_token_value
-            else None
+        bearer_token_value_node_input = create_node_input(
+            node_id=node_id,
+            input_name="bearer_token_value",
+            value=bearer_token_value,
+            display_context=display_context,
+            input_id=self.bearer_token_value_input_id,
+            pointer_type=WorkspaceSecretPointer,
         )
         api_key_header_key_node_input = (
             create_node_input(
@@ -101,52 +99,52 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             if api_key_header_key
             else None
         )
-        api_key_header_value_node_input = (
-            create_node_input(
-                node_id=node_id,
-                input_name="api_key_header_value",
-                value=node.api_key_header_value,
-                display_context=display_context,
-                input_id=self.api_key_header_value_input_id,
-            )
-            if headers and api_key_header_key and api_key_header_value
-            else None
+        api_key_header_value_node_input = create_node_input(
+            node_id=node_id,
+            input_name="api_key_header_value",
+            value=api_key_header_value,
+            display_context=display_context,
+            input_id=self.api_key_header_value_input_id,
+            pointer_type=WorkspaceSecretPointer,
         )
 
-        # TODO: Add stable IDs for additional headers
-        # https://app.shortcut.com/vellum/story/5083
-        additional_headers: JsonArray = (
-            [
-                {
-                    "header_key_input_id": create_node_input(
-                        node_id=node_id,
-                        input_name="additional_header_key",
-                        value=key,
-                        display_context=display_context,
-                        input_id=(
-                            self.additional_header_key_input_ids.get(key)
-                            if self.additional_header_key_input_ids
-                            else None
-                        ),
-                    ).id,
-                    "header_value_input_id": create_node_input(
-                        node_id=node_id,
-                        input_name="additional_header_value",
-                        value=value,
-                        display_context=display_context,
-                        input_id=(
-                            self.additional_header_value_input_ids.get(key)
-                            if self.additional_header_value_input_ids
-                            else None
-                        ),
-                    ).id,
-                }
-                for key, value in headers.items()
-                if key not in {api_key_header_key, "Authorization"}
-            ]
-            if headers
-            else []
-        )
+        additional_header_inputs = []
+
+        additional_headers: JsonArray = []
+        if headers:
+            for key, value in headers.items():
+                if key in {api_key_header_key, "Authorization"}:
+                    continue
+
+                header_key_input = create_node_input(
+                    node_id=node_id,
+                    input_name="additional_header_key",
+                    value=key,
+                    display_context=display_context,
+                    input_id=(
+                        self.additional_header_key_input_ids.get(key) if self.additional_header_key_input_ids else None
+                    ),
+                )
+                header_value_input = create_node_input(
+                    node_id=node_id,
+                    input_name="additional_header_value",
+                    value=value,
+                    display_context=display_context,
+                    input_id=(
+                        self.additional_header_value_input_ids.get(key)
+                        if self.additional_header_value_input_ids
+                        else None
+                    ),
+                )
+
+                additional_header_inputs.extend([header_key_input, header_value_input])
+
+                additional_headers.append(
+                    {
+                        "header_key_input_id": header_key_input.id,
+                        "header_value_input_id": header_value_input.id,
+                    }
+                )
 
         inputs = [
             input
@@ -161,6 +159,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             ]
             if input is not None
         ]
+        inputs.extend(additional_header_inputs)
 
         _, text_output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.text)]
         _, json_output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.json)]

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/nodes/vellum/merge_node.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Any, ClassVar, Generic, List, Optional, TypeVar
+from typing import Any, ClassVar, Generic, List, Optional, Type, TypeVar
 
 from vellum.workflows.nodes.displayable import MergeNode
 from vellum.workflows.types.core import JsonObject
@@ -14,6 +14,10 @@ _MergeNodeType = TypeVar("_MergeNodeType", bound=MergeNode)
 class BaseMergeNodeDisplay(BaseNodeVellumDisplay[_MergeNodeType], Generic[_MergeNodeType]):
     target_handle_ids: ClassVar[List[UUID]]
 
+    def __init__(self, node: Type[_MergeNodeType]):
+        super().__init__(node)
+        self._target_handle_iterator = 0
+
     def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
         node = self._node
         node_id = self.node_id
@@ -46,3 +50,18 @@ class BaseMergeNodeDisplay(BaseNodeVellumDisplay[_MergeNodeType], Generic[_Merge
 
     def get_target_handle_ids(self) -> Optional[List[UUID]]:
         return self._get_explicit_node_display_attr("target_handle_ids", List[UUID])
+
+    def get_target_handle_id_by_source_node_id(self, source_node_id: UUID) -> UUID:
+        target_handle_ids = self.get_target_handle_ids()
+        if target_handle_ids is None:
+            return uuid4_from_hash(f"{self.node_id}|target_handle|{source_node_id}")
+
+        # Edges call this method to know which handle to connect to
+        # We use the order of the edges to determine the handle id. This is quite brittle to the order of the
+        # edges matching the order of the Merge Node's data.target_handles attribute. We should look into a
+        # longer term solution, or cutover Merge Nodes to Generic Nodes soon
+        target_handle_id = target_handle_ids[self._target_handle_iterator]
+        self._target_handle_iterator += 1
+        if self._target_handle_iterator >= len(self.target_handle_ids):
+            self._target_handle_iterator = 0
+        return target_handle_id

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Generic, Optional, TypeVar
+from typing import ClassVar, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.core.templating_node import TemplatingNode
 from vellum.workflows.types.core import JsonObject
@@ -11,10 +11,11 @@ from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _TemplatingNodeType = TypeVar("_TemplatingNodeType", bound=TemplatingNode)
 
+TEMPLATE_INPUT_NAME = "template"
+
 
 class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Generic[_TemplatingNodeType]):
     template_input_id: ClassVar[Optional[UUID]] = None
-    input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
@@ -22,12 +23,21 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
         node = self._node
         node_id = self.node_id
 
+        template_input_id = self.template_input_id or next(
+            (
+                input_id
+                for input_name, input_id in self.node_input_ids_by_name.items()
+                if input_name == TEMPLATE_INPUT_NAME
+            ),
+            None,
+        )
+
         template_node_input = create_node_input(
             node_id=node_id,
             input_name="template",
             value=node.template,
             display_context=display_context,
-            input_id=self.template_input_id,
+            input_id=template_input_id,
         )
         template_node_inputs = raise_if_descriptor(node.inputs)
         template_inputs = [
@@ -36,9 +46,10 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
                 input_name=variable_name,
                 value=variable_value,
                 display_context=display_context,
-                input_id=self.input_ids_by_name.get("template"),
+                input_id=self.node_input_ids_by_name.get(variable_name),
             )
             for variable_name, variable_value in template_node_inputs.items()
+            if variable_name != TEMPLATE_INPUT_NAME
         ]
         node_inputs = [template_node_input, *template_inputs]
 

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/nodes/vellum/utils.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Any, List, Optional, cast
+from typing import Any, List, Optional, Type, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
@@ -13,6 +13,8 @@ from vellum_ee.workflows.display.vellum import (
     NodeInput,
     NodeInputValuePointer,
     NodeInputValuePointerRule,
+    WorkspaceSecretData,
+    WorkspaceSecretPointer,
 )
 
 
@@ -22,6 +24,7 @@ def create_node_input(
     value: Any,
     display_context: WorkflowDisplayContext,
     input_id: Optional[UUID],
+    pointer_type: Optional[Type[NodeInputValuePointerRule]] = ConstantValuePointer,
 ) -> NodeInput:
     input_id = input_id or uuid4_from_hash(f"{node_id}|{input_name}")
     if (
@@ -33,7 +36,7 @@ def create_node_input(
         if wrapped_node._is_wrapped_node:
             value = getattr(wrapped_node.Outputs, value.name)
 
-    rules = create_node_input_value_pointer_rules(value, display_context)
+    rules = create_node_input_value_pointer_rules(value, display_context, pointer_type=pointer_type)
     return NodeInput(
         id=str(input_id),
         key=input_name,
@@ -48,6 +51,7 @@ def create_node_input_value_pointer_rules(
     value: Any,
     display_context: WorkflowDisplayContext,
     existing_rules: Optional[List[NodeInputValuePointerRule]] = None,
+    pointer_type: Optional[Type[NodeInputValuePointerRule]] = None,
 ) -> List[NodeInputValuePointerRule]:
     node_input_value_pointer_rules: List[NodeInputValuePointerRule] = existing_rules or []
 
@@ -59,18 +63,34 @@ def create_node_input_value_pointer_rules(
 
         if isinstance(value, CoalesceExpression):
             # Recursively handle the left-hand side
-            lhs_rules = create_node_input_value_pointer_rules(value.lhs, display_context, [])
+            lhs_rules = create_node_input_value_pointer_rules(value.lhs, display_context, [], pointer_type=pointer_type)
             node_input_value_pointer_rules.extend(lhs_rules)
 
             # Handle the right-hand side
             if not isinstance(value.rhs, CoalesceExpression):
-                rhs_rules = create_node_input_value_pointer_rules(value.rhs, display_context, [])
+                rhs_rules = create_node_input_value_pointer_rules(
+                    value.rhs, display_context, [], pointer_type=pointer_type
+                )
                 node_input_value_pointer_rules.extend(rhs_rules)
         else:
             # Non-CoalesceExpression case
             node_input_value_pointer_rules.append(create_node_input_value_pointer_rule(value, display_context))
     else:
-        vellum_variable_value = primitive_to_vellum_value(value)
-        node_input_value_pointer_rules.append(ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_variable_value))
+        pointer = create_pointer(value, pointer_type)
+        node_input_value_pointer_rules.append(pointer)
 
     return node_input_value_pointer_rules
+
+
+def create_pointer(
+    value: Any,
+    pointer_type: Optional[Type[NodeInputValuePointerRule]] = None,
+) -> NodeInputValuePointerRule:
+    if value is None:
+        if pointer_type is WorkspaceSecretPointer:
+            return WorkspaceSecretPointer(
+                type="WORKSPACE_SECRET", data=WorkspaceSecretData(type="STRING", workspace_secret_id=None)
+            )
+
+    vellum_variable_value = primitive_to_vellum_value(value)
+    return ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_variable_value)

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_api_node_serialization.py

@@ -119,6 +119,16 @@ def test_serialize_workflow(vellum_client):
                         "combinator": "OR",
                     },
                 },
+                {
+                    "id": "fee5e3c9-442a-4922-ba80-5ee07361cea7",
+                    "key": "bearer_token_value",
+                    "value": {
+                        "rules": [
+                            {"type": "WORKSPACE_SECRET", "data": {"type": "STRING", "workspace_secret_id": None}}
+                        ],
+                        "combinator": "OR",
+                    },
+                },
                 {
                     "id": "2fcdfbc3-8095-4277-bb4a-a201fd326b54",
                     "key": "api_key_header_key",
@@ -143,6 +153,24 @@ def test_serialize_workflow(vellum_client):
                         "combinator": "OR",
                     },
                 },
+                {
+                    "id": "57c31247-998a-430d-bb62-bf50eca7df35",
+                    "key": "additional_header_key",
+                    "value": {
+                        "rules": [{"type": "CONSTANT_VALUE", "data": {"type": "STRING", "value": "additional_header"}}],
+                        "combinator": "OR",
+                    },
+                },
+                {
+                    "id": "47b32274-f19b-4c15-b788-55c069c311c5",
+                    "key": "additional_header_value",
+                    "value": {
+                        "rules": [
+                            {"type": "CONSTANT_VALUE", "data": {"type": "STRING", "value": "additional header value"}}
+                        ],
+                        "combinator": "OR",
+                    },
+                },
             ],
             "data": {
                 "label": "Simple A P I Node",
@@ -153,7 +181,7 @@ def test_serialize_workflow(vellum_client):
                 "method_input_id": "fd61b5ac-39f9-4cfe-a839-f8ce78c202df",
                 "body_input_id": "c3a17ceb-e201-4025-b18a-9162aac7705e",
                 "authorization_type_input_id": "3092bf23-3202-4f3e-874c-9a33ccc73459",
-                "bearer_token_value_input_id": None,
+                "bearer_token_value_input_id": "fee5e3c9-442a-4922-ba80-5ee07361cea7",
                 "api_key_header_key_input_id": "2fcdfbc3-8095-4277-bb4a-a201fd326b54",
                 "api_key_header_value_input_id": "d794bb51-a419-4fd8-be63-dfaf4166e831",
                 "additional_headers": [

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_merge_node_serialization.py

@@ -218,7 +218,7 @@ def test_serialize_workflow__await_all():
                 "source_node_id": "59243c65-053f-4ea6-9157-3f3edb1477bf",
                 "source_handle_id": "b9c5f52b-b714-46e8-a09c-38b4e770dd36",
                 "target_node_id": "37c10e8a-771b-432b-a767-31f5007851f0",
-                "target_handle_id": "0efd256f-f5f6-45fe-9adb-651780f5e63d",
+                "target_handle_id": "42eeb66c-9792-4609-8c71-3a56f668f4dc",
                 "type": "DEFAULT",
             },
             {
@@ -226,7 +226,7 @@ def test_serialize_workflow__await_all():
                 "source_node_id": "127ef456-91bc-43c6-bd8b-1772db5e3cb5",
                 "source_handle_id": "b0bd17f3-4ce6-4232-9666-ec8afa161bf2",
                 "target_node_id": "37c10e8a-771b-432b-a767-31f5007851f0",
-                "target_handle_id": "0efd256f-f5f6-45fe-9adb-651780f5e63d",
+                "target_handle_id": "f40ff7fb-de1b-4aa4-ba3c-7630f7357cbf",
                 "type": "DEFAULT",
             },
             {

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/vellum.py

@@ -74,7 +74,9 @@ class WorkflowMetaVellumDisplay(WorkflowMetaVellumDisplayOverrides):
 
 @dataclass
 class WorkflowInputsVellumDisplayOverrides(WorkflowInputsDisplay, WorkflowInputsDisplayOverrides):
-    pass
+    name: Optional[str] = None
+    required: Optional[bool] = None
+    color: Optional[str] = None
 
 
 @dataclass
@@ -115,8 +117,6 @@ class WorkflowOutputVellumDisplayOverrides(WorkflowOutputDisplay, WorkflowOutput
     target_handle_id: UUID
     display_data: NodeDisplayData
     edge_id: UUID
-    # source_node_id: Optional[UUID]
-    # source_handle_id: Optional[UUID]
 
 
 @dataclass
@@ -202,7 +202,7 @@ class InputVariablePointer(UniversalBaseModel):
 
 class WorkspaceSecretData(UniversalBaseModel):
     type: VellumVariableType
-    workspace_secret_id: str
+    workspace_secret_id: Optional[str] = None
 
 
 class WorkspaceSecretPointer(UniversalBaseModel):

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/ee/vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -12,9 +12,9 @@ from vellum.workflows.references import WorkflowInputReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.types.generics import WorkflowType
+from vellum_ee.workflows.display.nodes import BaseMergeNodeDisplay
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.types import PortDisplay
-from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type, primitive_to_vellum_value
@@ -57,17 +57,17 @@ class VellumWorkflowDisplay(
     def serialize(self, raise_errors: bool = True) -> JsonObject:
         input_variables: JsonArray = []
         for workflow_input, workflow_input_display in self.display_context.workflow_input_displays.items():
-            default = (
-                primitive_to_vellum_value(raise_if_descriptor(workflow_input.instance))
-                if workflow_input.instance
-                else None
+            default = primitive_to_vellum_value(workflow_input.instance) if workflow_input.instance else None
+            required = (
+                workflow_input_display.required
+                if workflow_input_display.required is not None
+                else type(None) not in workflow_input.types
             )
-            required = type(None) not in workflow_input.types
 
             input_variables.append(
                 {
                     "id": str(workflow_input_display.id),
-                    "key": workflow_input.name,
+                    "key": workflow_input_display.name or workflow_input.name,
                     "type": infer_vellum_variable_type(workflow_input),
                     "default": default.dict() if default else None,
                     "required": required,
@@ -270,12 +270,16 @@ class VellumWorkflowDisplay(
         self, workflow_input: WorkflowInputReference, overrides: Optional[WorkflowInputsVellumDisplayOverrides] = None
     ) -> WorkflowInputsVellumDisplay:
         workflow_input_id: UUID
+        required = None
+        color = None
         if overrides:
             workflow_input_id = overrides.id
+            required = overrides.required
+            color = overrides.color
         else:
             workflow_input_id = uuid4_from_hash(f"{self.workflow_id}|inputs|id|{workflow_input.name}")
 
-        return WorkflowInputsVellumDisplay(id=workflow_input_id)
+        return WorkflowInputsVellumDisplay(id=workflow_input_id, required=required, color=color)
 
     def _generate_entrypoint_display(
         self,
@@ -363,7 +367,12 @@ class VellumWorkflowDisplay(
 
         target_node_display = node_displays[target_node]
         target_node_id = target_node_display.node_id
-        target_handle_id = target_node_display.get_target_handle_id()
+
+        target_handle_id: UUID
+        if isinstance(target_node_display, BaseMergeNodeDisplay):
+            target_handle_id = target_node_display.get_target_handle_id_by_source_node_id(source_node_id)
+        else:
+            target_handle_id = target_node_display.get_target_handle_id()
 
         return self._generate_edge_display_from_source(
             source_node_id, source_handle_id, target_node_id, target_handle_id, overrides

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/pyproject.toml

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

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/src/vellum/__init__.py

@@ -319,6 +319,7 @@ from .types import (
     SentenceChunkingRequest,
     SlimDeploymentRead,
     SlimDocument,
+    SlimDocumentDocumentToDocumentIndex,
     SlimWorkflowDeployment,
     StreamingAdHocExecutePromptEvent,
     StreamingExecutePromptEvent,
@@ -393,6 +394,10 @@ from .types import (
     TestSuiteRunMetricNumberOutput,
     TestSuiteRunMetricOutput,
     TestSuiteRunMetricStringOutput,
+    TestSuiteRunPromptSandboxHistoryItemExecConfig,
+    TestSuiteRunPromptSandboxHistoryItemExecConfigData,
+    TestSuiteRunPromptSandboxHistoryItemExecConfigDataRequest,
+    TestSuiteRunPromptSandboxHistoryItemExecConfigRequest,
     TestSuiteRunRead,
     TestSuiteRunState,
     TestSuiteRunTestSuite,
@@ -400,6 +405,10 @@ from .types import (
     TestSuiteRunWorkflowReleaseTagExecConfigData,
     TestSuiteRunWorkflowReleaseTagExecConfigDataRequest,
     TestSuiteRunWorkflowReleaseTagExecConfigRequest,
+    TestSuiteRunWorkflowSandboxHistoryItemExecConfig,
+    TestSuiteRunWorkflowSandboxHistoryItemExecConfigData,
+    TestSuiteRunWorkflowSandboxHistoryItemExecConfigDataRequest,
+    TestSuiteRunWorkflowSandboxHistoryItemExecConfigRequest,
     TestSuiteTestCase,
     TestSuiteTestCaseBulkOperationRequest,
     TestSuiteTestCaseBulkResult,
@@ -843,6 +852,7 @@ __all__ = [
     "SentenceChunkingRequest",
     "SlimDeploymentRead",
     "SlimDocument",
+    "SlimDocumentDocumentToDocumentIndex",
     "SlimWorkflowDeployment",
     "StreamingAdHocExecutePromptEvent",
     "StreamingExecutePromptEvent",
@@ -917,6 +927,10 @@ __all__ = [
     "TestSuiteRunMetricNumberOutput",
     "TestSuiteRunMetricOutput",
     "TestSuiteRunMetricStringOutput",
+    "TestSuiteRunPromptSandboxHistoryItemExecConfig",
+    "TestSuiteRunPromptSandboxHistoryItemExecConfigData",
+    "TestSuiteRunPromptSandboxHistoryItemExecConfigDataRequest",
+    "TestSuiteRunPromptSandboxHistoryItemExecConfigRequest",
     "TestSuiteRunRead",
     "TestSuiteRunState",
     "TestSuiteRunTestSuite",
@@ -924,6 +938,10 @@ __all__ = [
     "TestSuiteRunWorkflowReleaseTagExecConfigData",
     "TestSuiteRunWorkflowReleaseTagExecConfigDataRequest",
     "TestSuiteRunWorkflowReleaseTagExecConfigRequest",
+    "TestSuiteRunWorkflowSandboxHistoryItemExecConfig",
+    "TestSuiteRunWorkflowSandboxHistoryItemExecConfigData",
+    "TestSuiteRunWorkflowSandboxHistoryItemExecConfigDataRequest",
+    "TestSuiteRunWorkflowSandboxHistoryItemExecConfigRequest",
     "TestSuiteTestCase",
     "TestSuiteTestCaseBulkOperationRequest",
     "TestSuiteTestCaseBulkResult",

{vellum_ai-0.11.0 → vellum_ai-0.11.3}/src/vellum/client/core/client_wrapper.py

@@ -17,7 +17,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.11.0",
+            "X-Fern-SDK-Version": "0.11.2",
         }
         headers["X_API_KEY"] = self.api_key
         return headers