vellum-ai 0.14.26__tar.gz → 0.14.28__tar.gz

{vellum_ai-0.14.26 → vellum_ai-0.14.28}/PKG-INFO

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

{vellum_ai-0.14.26 → vellum_ai-0.14.28}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -94,7 +94,8 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
                 input_name=variable_name,
                 value=variable_value,
                 display_context=display_context,
-                input_id=self.node_input_ids_by_name.get(variable_name),
+                input_id=self.node_input_ids_by_name.get(f"{InlinePromptNode.prompt_inputs.name}.{variable_name}")
+                or self.node_input_ids_by_name.get(variable_name),
             )
             vellum_variable_type = infer_vellum_variable_type(variable_value)
             node_inputs.append(node_input)

vellum_ai-0.14.28/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py

@@ -0,0 +1,131 @@
+import pytest
+from uuid import UUID
+from typing import Type
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+from vellum.workflows.references.lazy import LazyReference
+from vellum_ee.workflows.display.nodes.vellum.inline_prompt_node import BaseInlinePromptNodeDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
+
+
+def test_serialize_node__lazy_reference_in_prompt_inputs():
+    # GIVEN a prompt node with a lazy reference in the prompt inputs
+    class LazyReferencePromptNode(InlinePromptNode):
+        prompt_inputs = {"attr": LazyReference[str]("OtherNode.Outputs.result")}
+        blocks = []
+        ml_model = "gpt-4o"
+
+    class OtherNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a workflow with both nodes
+    class Workflow(BaseWorkflow):
+        graph = LazyReferencePromptNode >> OtherNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the attribute reference
+    lazy_reference_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(LazyReferencePromptNode.__id__)
+    )
+
+    assert lazy_reference_node["inputs"] == [
+        {
+            "id": "aa81c1bc-d5d8-4ae8-8946-e9f4d0c1ab5f",
+            "key": "attr",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "NODE_OUTPUT",
+                        "data": {
+                            "node_id": str(OtherNode.__id__),
+                            "output_id": "7f377cb8-4eca-4f1c-9239-9925f9495d84",
+                        },
+                    }
+                ],
+            },
+        }
+    ]
+
+
+def _no_display_class(Node: Type[InlinePromptNode]):
+    return None
+
+
+def _display_class_with_node_input_ids_by_name(Node: Type[InlinePromptNode]):
+    class PromptNodeDisplay(BaseInlinePromptNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return PromptNodeDisplay
+
+
+def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[InlinePromptNode]):
+    class PromptNodeDisplay(BaseInlinePromptNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"prompt_inputs.foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return PromptNodeDisplay
+
+
+@pytest.mark.parametrize(
+    ["GetDisplayClass", "expected_input_id"],
+    [
+        (_no_display_class, "8aa4ce7f-5eb8-41b7-abd0-ea2b40c8fb88"),
+        (_display_class_with_node_input_ids_by_name, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
+        (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
+    ],
+    ids=[
+        "no_display_class",
+        "display_class_with_node_input_ids_by_name",
+        "display_class_with_node_input_ids_by_name_with_inputs_prefix",
+    ],
+)
+def test_serialize_node__prompt_inputs(GetDisplayClass, expected_input_id):
+    # GIVEN a prompt node with inputs
+    class MyPromptNode(InlinePromptNode):
+        prompt_inputs = {"foo": "bar"}
+        blocks = []
+        ml_model = "gpt-4o"
+
+    # AND a workflow with the prompt node
+    class Workflow(BaseWorkflow):
+        graph = MyPromptNode
+
+    # AND a display class
+    GetDisplayClass(MyPromptNode)
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the inputs
+    my_prompt_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["id"] == str(MyPromptNode.__id__)
+    )
+
+    assert my_prompt_node["inputs"] == [
+        {
+            "id": expected_input_id,
+            "key": "foo",
+            "value": {
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "bar",
+                        },
+                    }
+                ],
+                "combinator": "OR",
+            },
+        }
+    ]

{vellum_ai-0.14.26 → vellum_ai-0.14.28}/ee/vellum_ee/workflows/server/virtual_file_loader.py

@@ -1,5 +1,7 @@
 import importlib
+from importlib.machinery import ModuleSpec
 import re
+import sys
 from typing import Optional
 
 
@@ -8,11 +10,20 @@ class VirtualFileLoader(importlib.abc.Loader):
         self.files = files
         self.namespace = namespace
 
-    def create_module(self, spec):
-        return None  # use default module creation
+    def create_module(self, spec: ModuleSpec):
+        """
+        We started with cpython/Lib/importlib/_bootstrap.py::FrozenImporter::create_module here
+
+        https://github.com/python/cpython/blob/053c285f6b41f92fbdd1d4ff0c959cceefacd7cd/Lib/importlib/_bootstrap.py#L1160C1-L1169C22
+
+        and reduced our needs to just updating the __file__ attribute directly.
+        """
+        module = type(sys)(spec.name)
+        module.__file__ = spec.origin
+        return module
 
     def exec_module(self, module):
-        module_info = self._resolve_module(module.__spec__.origin)
+        module_info = self._resolve_module(module.__spec__.name)
 
         if module_info:
             file_path, code = module_info
@@ -66,7 +77,8 @@ class VirtualFileFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
             return importlib.machinery.ModuleSpec(
                 fullname,
                 self.loader,
-                origin=fullname,
+                origin=file_path,
                 is_package=is_package,
             )
+
         return None

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

@@ -0,0 +1,150 @@
+import pytest
+import sys
+from uuid import uuid4
+from typing import Type, cast
+
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types.code_executor_response import CodeExecutorResponse
+from vellum.client.types.number_vellum_value import NumberVellumValue
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import BaseNode
+from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
+
+
+@pytest.fixture
+def mock_open(mocker):
+    return mocker.patch("vellum.workflows.nodes.displayable.code_execution_node.utils.open")
+
+
+def test_load_workflow_event_display_context():
+    # DEPRECATED: Use `vellum.workflows.events.workflow.WorkflowEventDisplayContext` instead. Will be removed in 0.15.0
+    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)
+
+
+def test_load_from_module__lazy_reference_in_file_loader():
+    # GIVEN a workflow module with a node containing a lazy reference
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class Workflow(BaseWorkflow):
+    graph = StartNode
+""",
+        "nodes/__init__.py": """\
+from .start_node import StartNode
+
+__all__ = [
+    "StartNode",
+]
+""",
+        "nodes/start_node.py": """\
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.references import LazyReference
+
+class StartNode(BaseNode):
+    foo = LazyReference(lambda: StartNode.Outputs.bar)
+
+    class Outputs(BaseNode.Outputs):
+        bar = str
+""",
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    # WHEN the workflow is loaded
+    Workflow = BaseWorkflow.load_from_module(namespace)
+    workflow = Workflow()
+
+    # THEN the workflow is successfully initialized
+    assert workflow
+
+    # AND the graph is just a BaseNode
+    # ideally this would be true, but the loader uses a different BaseNode class definition than
+    # the one in this test module.
+    # assert isinstance(workflow.graph, BaseNode)
+    start_node = cast(Type[BaseNode], workflow.graph)
+    assert start_node.__bases__ == (BaseNode,)
+
+    # AND the lazy reference has the correct name
+    assert start_node.foo.instance
+    assert start_node.foo.instance.name == "StartNode.Outputs.bar"
+
+
+def test_load_from_module__ts_code_in_file_loader(
+    mock_open,
+    vellum_client,
+):
+    # GIVEN typescript code
+    ts_code = """async function main(): any {
+  return 5;
+}"""
+
+    # AND a workflow module with only a code execution node
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.code_execution_node import CodeExecutionNode
+
+class Workflow(BaseWorkflow):
+    graph = CodeExecutionNode
+""",
+        "nodes/__init__.py": """\
+from .code_execution_node import CodeExecutionNode
+
+__all__ = ["CodeExecutionNode"]
+""",
+        "nodes/code_execution_node.py": """\
+from typing import Any
+
+from vellum.workflows.nodes.displayable import CodeExecutionNode as BaseCodeExecutionNode
+from vellum.workflows.state import BaseState
+
+class CodeExecutionNode(BaseCodeExecutionNode[BaseState, int]):
+    filepath = "./script.ts"
+    code_inputs = {}
+    runtime = "TYPESCRIPT_5_3_3"
+    packages = []
+""",
+        "nodes/code_execution_node/script.ts": ts_code,
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    # AND the open function returns our file content
+    mock_open.return_value.__enter__.return_value.read.return_value = ts_code
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="hello",
+        output=NumberVellumValue(value=5),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
+    # WHEN the workflow is loaded
+    Workflow = BaseWorkflow.load_from_module(namespace)
+    workflow = Workflow()
+
+    # THEN the workflow is successfully initialized
+    assert workflow
+
+    event = workflow.run()
+    assert event.name == "workflow.execution.fulfilled", event.model_dump_json()
+
+    # AND we pass in the correct file path to the open function
+    assert mock_open.call_args[0][0] == f"{namespace}/nodes/./script.ts"
+
+    # AND we invoke the Code Execution Node with the correct code
+    assert vellum_client.execute_code.call_args.kwargs["code"] == ts_code

{vellum_ai-0.14.26 → vellum_ai-0.14.28}/pyproject.toml

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

{vellum_ai-0.14.26 → vellum_ai-0.14.28}/src/vellum/__init__.py

@@ -300,6 +300,7 @@ from .types import (
     PromptDeploymentExpandMetaRequest,
     PromptDeploymentInputRequest,
     PromptDeploymentParentContext,
+    PromptExecConfig,
     PromptExecutionMeta,
     PromptNodeExecutionMeta,
     PromptNodeResult,
@@ -589,6 +590,7 @@ from .resources import (
     metric_definitions,
     ml_models,
     organizations,
+    prompts,
     sandboxes,
     test_suite_runs,
     test_suites,
@@ -910,6 +912,7 @@ __all__ = [
     "PromptDeploymentExpandMetaRequest",
     "PromptDeploymentInputRequest",
     "PromptDeploymentParentContext",
+    "PromptExecConfig",
     "PromptExecutionMeta",
     "PromptNodeExecutionMeta",
     "PromptNodeResult",
@@ -1193,6 +1196,7 @@ __all__ = [
     "metric_definitions",
     "ml_models",
     "organizations",
+    "prompts",
     "sandboxes",
     "test_suite_runs",
     "test_suites",

{vellum_ai-0.14.26 → vellum_ai-0.14.28}/src/vellum/client/__init__.py

@@ -13,6 +13,7 @@ from .resources.folder_entities.client import FolderEntitiesClient
 from .resources.metric_definitions.client import MetricDefinitionsClient
 from .resources.ml_models.client import MlModelsClient
 from .resources.organizations.client import OrganizationsClient
+from .resources.prompts.client import PromptsClient
 from .resources.sandboxes.client import SandboxesClient
 from .resources.test_suite_runs.client import TestSuiteRunsClient
 from .resources.test_suites.client import TestSuitesClient
@@ -69,6 +70,7 @@ from .resources.folder_entities.client import AsyncFolderEntitiesClient
 from .resources.metric_definitions.client import AsyncMetricDefinitionsClient
 from .resources.ml_models.client import AsyncMlModelsClient
 from .resources.organizations.client import AsyncOrganizationsClient
+from .resources.prompts.client import AsyncPromptsClient
 from .resources.sandboxes.client import AsyncSandboxesClient
 from .resources.test_suite_runs.client import AsyncTestSuiteRunsClient
 from .resources.test_suites.client import AsyncTestSuitesClient
@@ -145,6 +147,7 @@ class Vellum:
         self.metric_definitions = MetricDefinitionsClient(client_wrapper=self._client_wrapper)
         self.ml_models = MlModelsClient(client_wrapper=self._client_wrapper)
         self.organizations = OrganizationsClient(client_wrapper=self._client_wrapper)
+        self.prompts = PromptsClient(client_wrapper=self._client_wrapper)
         self.sandboxes = SandboxesClient(client_wrapper=self._client_wrapper)
         self.test_suite_runs = TestSuiteRunsClient(client_wrapper=self._client_wrapper)
         self.test_suites = TestSuitesClient(client_wrapper=self._client_wrapper)
@@ -1486,6 +1489,7 @@ class AsyncVellum:
         self.metric_definitions = AsyncMetricDefinitionsClient(client_wrapper=self._client_wrapper)
         self.ml_models = AsyncMlModelsClient(client_wrapper=self._client_wrapper)
         self.organizations = AsyncOrganizationsClient(client_wrapper=self._client_wrapper)
+        self.prompts = AsyncPromptsClient(client_wrapper=self._client_wrapper)
         self.sandboxes = AsyncSandboxesClient(client_wrapper=self._client_wrapper)
         self.test_suite_runs = AsyncTestSuiteRunsClient(client_wrapper=self._client_wrapper)
         self.test_suites = AsyncTestSuitesClient(client_wrapper=self._client_wrapper)

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

{vellum_ai-0.14.26 → vellum_ai-0.14.28}/src/vellum/client/resources/__init__.py

@@ -10,6 +10,7 @@ from . import (
     metric_definitions,
     ml_models,
     organizations,
+    prompts,
     sandboxes,
     test_suite_runs,
     test_suites,
@@ -42,6 +43,7 @@ __all__ = [
     "metric_definitions",
     "ml_models",
     "organizations",
+    "prompts",
     "sandboxes",
     "test_suite_runs",
     "test_suites",

{vellum_ai-0.14.26 → vellum_ai-0.14.28}/src/vellum/client/resources/documents/client.py

@@ -277,13 +277,6 @@ class DocumentsClient:
 
         **Note:** Uses a base url of `https://documents.vellum.ai`.
 
-        This is a multipart/form-data request. The `contents` field should be a file upload. It also expects a JSON body with the following fields:
-        - `add_to_index_names: list[str]` - Optionally include the names of all indexes that you'd like this document to be included in
-        - `external_id: str | None` - Optionally include an external ID for this document. This is useful if you want to re-upload the same document later when its contents change and would like it to be re-indexed.
-        - `label: str` - A human-friendly name for this document. Typically the filename.
-        - `keywords: list[str] | None` - Optionally include a list of keywords that'll be associated with this document. Used when performing keyword searches.
-        - `metadata: dict[str, Any]` - A stringified JSON object containing any metadata associated with the document that you'd like to filter upon later.
-
         Parameters
         ----------
         label : str
@@ -673,13 +666,6 @@ class AsyncDocumentsClient:
 
         **Note:** Uses a base url of `https://documents.vellum.ai`.
 
-        This is a multipart/form-data request. The `contents` field should be a file upload. It also expects a JSON body with the following fields:
-        - `add_to_index_names: list[str]` - Optionally include the names of all indexes that you'd like this document to be included in
-        - `external_id: str | None` - Optionally include an external ID for this document. This is useful if you want to re-upload the same document later when its contents change and would like it to be re-indexed.
-        - `label: str` - A human-friendly name for this document. Typically the filename.
-        - `keywords: list[str] | None` - Optionally include a list of keywords that'll be associated with this document. Used when performing keyword searches.
-        - `metadata: dict[str, Any]` - A stringified JSON object containing any metadata associated with the document that you'd like to filter upon later.
-
         Parameters
         ----------
         label : str

vellum_ai-0.14.28/src/vellum/client/resources/prompts/client.py

@@ -0,0 +1,197 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.client_wrapper import SyncClientWrapper
+import typing
+from ...core.request_options import RequestOptions
+from ...types.prompt_exec_config import PromptExecConfig
+from ...core.jsonable_encoder import jsonable_encoder
+from ...core.pydantic_utilities import parse_obj_as
+from ...errors.bad_request_error import BadRequestError
+from ...errors.not_found_error import NotFoundError
+from json.decoder import JSONDecodeError
+from ...core.api_error import ApiError
+from ...core.client_wrapper import AsyncClientWrapper
+
+
+class PromptsClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def pull(
+        self,
+        id: str,
+        *,
+        prompt_variant_id: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> PromptExecConfig:
+        """
+        Used to pull the definition of a Prompt from Vellum.
+
+        Parameters
+        ----------
+        id : str
+            The ID of the Prompt to pull from. Prompt Sandbox IDs are currently supported.
+
+        prompt_variant_id : typing.Optional[str]
+            The ID of the Prompt Variant within a Prompt Sandbox to pull. Must be included if providing the ID of a Prompt Sandbox.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        PromptExecConfig
+
+
+        Examples
+        --------
+        from vellum import Vellum
+
+        client = Vellum(
+            api_key="YOUR_API_KEY",
+        )
+        client.prompts.pull(
+            id="id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/prompts/{jsonable_encoder(id)}/pull",
+            base_url=self._client_wrapper.get_environment().default,
+            method="GET",
+            params={
+                "prompt_variant_id": prompt_variant_id,
+            },
+            headers={
+                "Accept": "application/json",
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    PromptExecConfig,
+                    parse_obj_as(
+                        type_=PromptExecConfig,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # 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)
+
+
+class AsyncPromptsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def pull(
+        self,
+        id: str,
+        *,
+        prompt_variant_id: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> PromptExecConfig:
+        """
+        Used to pull the definition of a Prompt from Vellum.
+
+        Parameters
+        ----------
+        id : str
+            The ID of the Prompt to pull from. Prompt Sandbox IDs are currently supported.
+
+        prompt_variant_id : typing.Optional[str]
+            The ID of the Prompt Variant within a Prompt Sandbox to pull. Must be included if providing the ID of a Prompt Sandbox.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        PromptExecConfig
+
+
+        Examples
+        --------
+        import asyncio
+
+        from vellum import AsyncVellum
+
+        client = AsyncVellum(
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.prompts.pull(
+                id="id",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/prompts/{jsonable_encoder(id)}/pull",
+            base_url=self._client_wrapper.get_environment().default,
+            method="GET",
+            params={
+                "prompt_variant_id": prompt_variant_id,
+            },
+            headers={
+                "Accept": "application/json",
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    PromptExecConfig,
+                    parse_obj_as(
+                        type_=PromptExecConfig,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # 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)

vellum_ai-0.14.28/src/vellum/client/resources/workspaces/__init__.py

@@ -0,0 +1,2 @@
+# This file was auto-generated by Fern from our API Definition.
+