vellum-ai 0.13.20__tar.gz → 0.13.22__tar.gz

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/PKG-INFO

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

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/ee/vellum_cli/push.py

@@ -49,6 +49,9 @@ def push_command(
         else config.workflows
     )
 
+    if len(workflow_configs) > 1 and workspace:
+        workflow_configs = [w for w in workflow_configs if w.workspace == workspace]
+
     if len(workflow_configs) == 0:
         raise ValueError(f"No workflow config for '{module}' found in project to push.")
 
@@ -230,15 +233,11 @@ def push_command(
 Visit at: https://app.vellum.ai/workflow-sandboxes/{response.workflow_sandbox_id}"""
         )
 
-    requires_save = False
     if not workflow_config.workflow_sandbox_id:
         workflow_config.workflow_sandbox_id = response.workflow_sandbox_id
-        requires_save = True
 
     if not workflow_config.deployments and response.workflow_deployment_id:
         workflow_config.deployments.append(WorkflowDeploymentConfig(id=UUID(response.workflow_deployment_id)))
-        requires_save = True
 
-    if requires_save:
-        config.save()
-        logger.info("Updated vellum.lock file.")
+    config.save()
+    logger.info("Updated vellum.lock.json file.")

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/ee/vellum_cli/tests/test_push.py

@@ -489,7 +489,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
 
     # AND the workflow sandbox id arg passed in should be `None`
     call_args = vellum_client_class.return_value.workflows.push.call_args.kwargs
-    assert call_args["workflow_sandbox_id"] is None
+    assert call_args["workflow_sandbox_id"] is None, result.output
 
     # AND with the correct api key
     vellum_client_class.assert_called_once_with(
@@ -509,3 +509,83 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
             "deployments": [],
             "ignore": None,
         }
+
+
+def test_push__workspace_option__both_options_already_configured(mock_module, vellum_client_class):
+    # GIVEN a single workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    workflow_sandbox_id = mock_module.workflow_sandbox_id
+    set_pyproject_toml = mock_module.set_pyproject_toml
+    second_workflow_sandbox_id = str(uuid4())
+
+    # AND the module is configured twice
+    set_pyproject_toml(
+        {
+            "workflows": [
+                {
+                    "module": module,
+                    "workflow_sandbox_id": workflow_sandbox_id,
+                },
+                {
+                    "module": module,
+                    "workflow_sandbox_id": second_workflow_sandbox_id,
+                    "workspace": "my_other_workspace",
+                },
+            ],
+            "workspaces": [
+                {
+                    "name": "my_other_workspace",
+                    "api_key": "MY_OTHER_VELLUM_API_KEY",
+                }
+            ],
+        }
+    )
+
+    # AND the .env file has the other api key stored
+    with open(os.path.join(temp_dir, ".env"), "w") as f:
+        f.write(
+            """\
+VELLUM_API_KEY=abcdef123456
+MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
+"""
+        )
+
+    # AND a workflow exists in the module
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns  workflow sandbox id
+    vellum_client_class.return_value.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=second_workflow_sandbox_id,
+    )
+
+    # WHEN calling `vellum push` on strict mode
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module, "--workspace", "my_other_workspace"])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API once
+    vellum_client_class.return_value.workflows.push.assert_called_once()
+
+    # AND the workflow sandbox id arg passed in should be `None`
+    call_args = vellum_client_class.return_value.workflows.push.call_args.kwargs
+    assert call_args["workflow_sandbox_id"] == second_workflow_sandbox_id
+
+    # AND with the correct api key
+    vellum_client_class.assert_called_once_with(
+        api_key="aaabbbcccddd",
+        environment=mock.ANY,
+    )
+
+    # AND the vellum lock file should have the same two workflows
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        assert len(lock_file_content["workflows"]) == 2
+        assert lock_file_content["workflows"][0]["module"] == module
+        assert lock_file_content["workflows"][0]["workflow_sandbox_id"] == workflow_sandbox_id
+        assert lock_file_content["workflows"][0]["workspace"] == "default"
+        assert lock_file_content["workflows"][1]["module"] == module
+        assert lock_file_content["workflows"][1]["workflow_sandbox_id"] == second_workflow_sandbox_id
+        assert lock_file_content["workflows"][1]["workspace"] == "my_other_workspace"

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/ee/vellum_ee/workflows/display/types.py

@@ -14,11 +14,10 @@ from vellum_ee.workflows.display.base import (
     WorkflowMetaDisplayType,
     WorkflowOutputDisplayType,
 )
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
-from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+    from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay
     from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
 
 NodeDisplayType = TypeVar("NodeDisplayType", bound="BaseNodeDisplay")
@@ -63,32 +62,3 @@ class WorkflowDisplayContext(
     workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplayType] = field(default_factory=dict)
     edge_displays: Dict[Tuple[Port, Type[BaseNode]], EdgeDisplayType] = field(default_factory=dict)
     port_displays: Dict[Port, "PortDisplay"] = field(default_factory=dict)
-
-    def build_event_display_context(self) -> WorkflowEventDisplayContext:
-        workflow_outputs = {
-            output.name: self.workflow_output_displays[output].id for output in self.workflow_output_displays
-        }
-        workflow_inputs = {input.name: self.workflow_input_displays[input].id for input in self.workflow_input_displays}
-        node_displays = {str(node.__id__): self.node_displays[node] for node in self.node_displays}
-        temp_node_displays = {}
-        for node in node_displays:
-            current_node = node_displays[node]
-            input_display = {}
-            if issubclass(current_node.__class__, BaseNodeVellumDisplay):
-                input_display = current_node.node_input_ids_by_name  # type: ignore[attr-defined]
-            node_display_meta = {
-                output.name: current_node.output_display[output].id for output in current_node.output_display
-            }
-            port_display_meta = {port.name: current_node.port_displays[port].id for port in current_node.port_displays}
-
-            temp_node_displays[node] = NodeDisplay(
-                input_display=input_display,
-                output_display=node_display_meta,
-                port_display=port_display_meta,
-            )
-        display_meta = WorkflowEventDisplayContext(
-            workflow_outputs=workflow_outputs,
-            workflow_inputs=workflow_inputs,
-            node_displays=temp_node_displays,
-        )
-        return display_meta

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/ee/vellum_ee/workflows/display/utils/vellum.py

@@ -28,6 +28,7 @@ from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualTo
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.not_in import NotInExpression
 from vellum.workflows.expressions.or_ import OrExpression
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.references import OutputReference, WorkflowInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
@@ -76,6 +77,12 @@ def create_node_input_value_pointer_rule(
     value: Any, display_context: "WorkflowDisplayContext"
 ) -> NodeInputValuePointerRule:
     if isinstance(value, OutputReference):
+        if value not in display_context.global_node_output_displays:
+            if issubclass(value.outputs_class, BaseNode.Outputs):
+                raise ValueError(f"Reference to node '{value.outputs_class._node_class.__name__}' not found in graph.")
+
+            raise ValueError(f"Reference to outputs '{value.outputs_class.__qualname__}' is invalid.")
+
         upstream_node, output_display = display_context.global_node_output_displays[value]
         upstream_node_display = display_context.global_node_displays[upstream_node]
         return NodeOutputPointer(

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -29,9 +29,15 @@ from vellum_ee.workflows.display.base import (
     WorkflowOutputDisplayOverridesType,
     WorkflowOutputDisplayType,
 )
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
-from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext, WorkflowEventDisplayContext
+from vellum_ee.workflows.display.types import (
+    NodeDisplay,
+    NodeDisplayType,
+    WorkflowDisplayContext,
+    WorkflowEventDisplayContext,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -343,4 +349,42 @@ class BaseWorkflowDisplay(
             display_class = importlib.import_module(workflow_display_module)
         except ModuleNotFoundError:
             return None
-        return display_class.WorkflowDisplay(workflow_class).display_context.build_event_display_context()
+
+        display_context = display_class.WorkflowDisplay(workflow_class).display_context
+        if not isinstance(display_context, WorkflowDisplayContext):
+            return None
+
+        workflow_outputs = {
+            output.name: display_context.workflow_output_displays[output].id
+            for output in display_context.workflow_output_displays
+        }
+        workflow_inputs = {
+            input.name: display_context.workflow_input_displays[input].id
+            for input in display_context.workflow_input_displays
+        }
+        node_displays = {
+            str(node.__id__): display_context.node_displays[node] for node in display_context.node_displays
+        }
+        temp_node_displays = {}
+        for node in node_displays:
+            current_node = node_displays[node]
+            input_display = {}
+            if isinstance(current_node, BaseNodeVellumDisplay):
+                input_display = current_node.node_input_ids_by_name
+            node_display_meta = {
+                output.name: current_node.output_display[output].id for output in current_node.output_display
+            }
+            port_display_meta = {port.name: current_node.port_displays[port].id for port in current_node.port_displays}
+
+            temp_node_displays[node] = NodeDisplay(
+                input_display=input_display,
+                output_display=node_display_meta,
+                port_display=port_display_meta,
+            )
+
+        display_meta = WorkflowEventDisplayContext(
+            workflow_outputs=workflow_outputs,
+            workflow_inputs=workflow_inputs,
+            node_displays=temp_node_displays,
+        )
+        return display_meta

vellum_ai-0.13.22/ee/vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -0,0 +1,65 @@
+import pytest
+
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_serialize_workflow__node_referenced_in_workflow_outputs_not_in_graph():
+    # GIVEN a couple of nodes
+    class InNode(BaseNode):
+        pass
+
+    class OutNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            foo: str
+
+    # AND A workflow that references the OutNode in its outputs but only has the InNode in its graph
+    class Workflow(BaseWorkflow):
+        graph = InNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final = OutNode.Outputs.foo
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=Workflow,
+    )
+
+    # THEN it should raise an error
+    with pytest.raises(ValueError) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should be user friendly
+    assert str(exc_info.value) == "Failed to serialize output 'final': Reference to node 'OutNode' not found in graph."
+
+
+def test_serialize_workflow__workflow_outputs_reference_non_node_outputs():
+    # GIVEN one Workflow
+    class FirstWorkflow(BaseWorkflow):
+        class Outputs(BaseWorkflow.Outputs):
+            foo = "bar"
+
+    # AND A workflow that references the Outputs of that Workflow
+    class Workflow(BaseWorkflow):
+        class Outputs(BaseWorkflow.Outputs):
+            final = FirstWorkflow.Outputs.foo
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=Workflow,
+    )
+
+    # THEN it should raise an error
+    with pytest.raises(ValueError) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should be user friendly
+    assert (
+        str(exc_info.value)
+        == """Failed to serialize output 'final': Reference to outputs \
+'test_serialize_workflow__workflow_outputs_reference_non_node_outputs.<locals>.FirstWorkflow.Outputs' is invalid."""
+    )

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/ee/vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -129,13 +129,16 @@ class VellumWorkflowDisplay(
 
             if workflow_output.instance not in final_output_node_outputs:
                 # Create a synthetic terminal node only if there is no terminal node for this output
-                node_input = create_node_input(
-                    final_output_node_id,
-                    "node_input",
-                    # This is currently the wrapper node's output, but we want the wrapped node
-                    workflow_output.instance,
-                    self.display_context,
-                )
+                try:
+                    node_input = create_node_input(
+                        final_output_node_id,
+                        "node_input",
+                        # This is currently the wrapper node's output, but we want the wrapped node
+                        workflow_output.instance,
+                        self.display_context,
+                    )
+                except ValueError as e:
+                    raise ValueError(f"Failed to serialize output '{workflow_output.name}': {str(e)}") from e
 
                 source_node_display: Optional[BaseNodeDisplay]
                 first_rule = node_input.value.rules[0]

vellum_ai-0.13.22/ee/vellum_ee/workflows/tests/test_server.py

@@ -0,0 +1,9 @@
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
+
+
+def test_load_workflow_event_display_context():
+    from vellum_ee.workflows.display.types import WorkflowEventDisplayContext
+
+    # We are actually just ensuring there are no circular dependencies when
+    # our Workflow Server imports this class.
+    assert issubclass(WorkflowEventDisplayContext, UniversalBaseModel)

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/pyproject.toml

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

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/src/vellum/__init__.py

@@ -92,6 +92,10 @@ from .types import (
     ErrorInput,
     ErrorVellumValue,
     ErrorVellumValueRequest,
+    ExecuteApiRequestBearerToken,
+    ExecuteApiRequestBody,
+    ExecuteApiRequestHeadersValue,
+    ExecuteApiResponse,
     ExecutePromptEvent,
     ExecutePromptResponse,
     ExecuteWorkflowResponse,
@@ -183,6 +187,7 @@ from .types import (
     MetadataFilterRuleCombinator,
     MetadataFilterRuleRequest,
     MetadataFiltersRequest,
+    MethodEnum,
     MetricDefinitionExecution,
     MetricDefinitionHistoryItem,
     MetricDefinitionInput,
@@ -437,6 +442,7 @@ from .types import (
     VellumErrorRequest,
     VellumImage,
     VellumImageRequest,
+    VellumSecret,
     VellumValue,
     VellumValueLogicalConditionGroupRequest,
     VellumValueLogicalConditionRequest,
@@ -617,6 +623,10 @@ __all__ = [
     "ErrorInput",
     "ErrorVellumValue",
     "ErrorVellumValueRequest",
+    "ExecuteApiRequestBearerToken",
+    "ExecuteApiRequestBody",
+    "ExecuteApiRequestHeadersValue",
+    "ExecuteApiResponse",
     "ExecutePromptEvent",
     "ExecutePromptResponse",
     "ExecuteWorkflowResponse",
@@ -713,6 +723,7 @@ __all__ = [
     "MetadataFilterRuleCombinator",
     "MetadataFilterRuleRequest",
     "MetadataFiltersRequest",
+    "MethodEnum",
     "MetricDefinitionExecution",
     "MetricDefinitionHistoryItem",
     "MetricDefinitionInput",
@@ -970,6 +981,7 @@ __all__ = [
     "VellumErrorRequest",
     "VellumImage",
     "VellumImageRequest",
+    "VellumSecret",
     "VellumValue",
     "VellumValueLogicalConditionGroupRequest",
     "VellumValueLogicalConditionRequest",

{vellum_ai-0.13.20 → vellum_ai-0.13.22}/src/vellum/client/__init__.py

@@ -21,17 +21,22 @@ from .resources.workflow_sandboxes.client import WorkflowSandboxesClient
 from .resources.workflows.client import WorkflowsClient
 from .resources.workspace_secrets.client import WorkspaceSecretsClient
 from .resources.workspaces.client import WorkspacesClient
+from .types.method_enum import MethodEnum
+from .types.execute_api_request_body import ExecuteApiRequestBody
+from .types.execute_api_request_headers_value import ExecuteApiRequestHeadersValue
+from .types.execute_api_request_bearer_token import ExecuteApiRequestBearerToken
+from .core.request_options import RequestOptions
+from .types.execute_api_response import ExecuteApiResponse
+from .core.serialization import convert_and_respect_annotation_metadata
+from .core.pydantic_utilities import parse_obj_as
+from json.decoder import JSONDecodeError
+from .core.api_error import ApiError
 from .types.code_execution_runtime import CodeExecutionRuntime
 from .types.code_executor_input import CodeExecutorInput
 from .types.code_execution_package import CodeExecutionPackage
 from .types.vellum_variable_type import VellumVariableType
-from .core.request_options import RequestOptions
 from .types.code_executor_response import CodeExecutorResponse
-from .core.serialization import convert_and_respect_annotation_metadata
-from .core.pydantic_utilities import parse_obj_as
 from .errors.bad_request_error import BadRequestError
-from json.decoder import JSONDecodeError
-from .core.api_error import ApiError
 from .types.prompt_deployment_input_request import PromptDeploymentInputRequest
 from .types.prompt_deployment_expand_meta_request import PromptDeploymentExpandMetaRequest
 from .types.raw_prompt_execution_overrides_request import RawPromptExecutionOverridesRequest
@@ -149,6 +154,82 @@ class Vellum:
         self.workspace_secrets = WorkspaceSecretsClient(client_wrapper=self._client_wrapper)
         self.workspaces = WorkspacesClient(client_wrapper=self._client_wrapper)
 
+    def execute_api(
+        self,
+        *,
+        url: str,
+        method: typing.Optional[MethodEnum] = OMIT,
+        body: typing.Optional[ExecuteApiRequestBody] = OMIT,
+        headers: typing.Optional[typing.Dict[str, ExecuteApiRequestHeadersValue]] = OMIT,
+        bearer_token: typing.Optional[ExecuteApiRequestBearerToken] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> ExecuteApiResponse:
+        """
+        Parameters
+        ----------
+        url : str
+
+        method : typing.Optional[MethodEnum]
+
+        body : typing.Optional[ExecuteApiRequestBody]
+
+        headers : typing.Optional[typing.Dict[str, ExecuteApiRequestHeadersValue]]
+
+        bearer_token : typing.Optional[ExecuteApiRequestBearerToken]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        ExecuteApiResponse
+
+
+        Examples
+        --------
+        from vellum import Vellum
+
+        client = Vellum(
+            api_key="YOUR_API_KEY",
+        )
+        client.execute_api(
+            url="url",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/execute-api",
+            base_url=self._client_wrapper.get_environment().default,
+            method="POST",
+            json={
+                "url": url,
+                "method": method,
+                "body": convert_and_respect_annotation_metadata(
+                    object_=body, annotation=ExecuteApiRequestBody, direction="write"
+                ),
+                "headers": convert_and_respect_annotation_metadata(
+                    object_=headers, annotation=typing.Dict[str, ExecuteApiRequestHeadersValue], direction="write"
+                ),
+                "bearer_token": convert_and_respect_annotation_metadata(
+                    object_=bearer_token, annotation=ExecuteApiRequestBearerToken, direction="write"
+                ),
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    ExecuteApiResponse,
+                    parse_obj_as(
+                        type_=ExecuteApiResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
     def execute_code(
         self,
         *,
@@ -1414,6 +1495,90 @@ class AsyncVellum:
         self.workspace_secrets = AsyncWorkspaceSecretsClient(client_wrapper=self._client_wrapper)
         self.workspaces = AsyncWorkspacesClient(client_wrapper=self._client_wrapper)
 
+    async def execute_api(
+        self,
+        *,
+        url: str,
+        method: typing.Optional[MethodEnum] = OMIT,
+        body: typing.Optional[ExecuteApiRequestBody] = OMIT,
+        headers: typing.Optional[typing.Dict[str, ExecuteApiRequestHeadersValue]] = OMIT,
+        bearer_token: typing.Optional[ExecuteApiRequestBearerToken] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> ExecuteApiResponse:
+        """
+        Parameters
+        ----------
+        url : str
+
+        method : typing.Optional[MethodEnum]
+
+        body : typing.Optional[ExecuteApiRequestBody]
+
+        headers : typing.Optional[typing.Dict[str, ExecuteApiRequestHeadersValue]]
+
+        bearer_token : typing.Optional[ExecuteApiRequestBearerToken]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        ExecuteApiResponse
+
+
+        Examples
+        --------
+        import asyncio
+
+        from vellum import AsyncVellum
+
+        client = AsyncVellum(
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.execute_api(
+                url="url",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/execute-api",
+            base_url=self._client_wrapper.get_environment().default,
+            method="POST",
+            json={
+                "url": url,
+                "method": method,
+                "body": convert_and_respect_annotation_metadata(
+                    object_=body, annotation=ExecuteApiRequestBody, direction="write"
+                ),
+                "headers": convert_and_respect_annotation_metadata(
+                    object_=headers, annotation=typing.Dict[str, ExecuteApiRequestHeadersValue], direction="write"
+                ),
+                "bearer_token": convert_and_respect_annotation_metadata(
+                    object_=bearer_token, annotation=ExecuteApiRequestBearerToken, direction="write"
+                ),
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    ExecuteApiResponse,
+                    parse_obj_as(
+                        type_=ExecuteApiResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
     async def execute_code(
         self,
         *,

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