vellum-ai 1.0.0__tar.gz → 1.0.1__tar.gz

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/PKG-INFO

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

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_cli/tests/test_ping.py

@@ -26,6 +26,7 @@ def test_ping__happy_path(vellum_client):
         name="Test Organization",
         new_member_join_behavior="AUTO_ACCEPT_FROM_SHARED_DOMAIN",
         allow_staff_access=True,
+        limit_config={},
     )
 
     # WHEN calling `vellum ping`

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -247,6 +247,30 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
         return ports
 
+    def _serialize_attributes(self, display_context: "WorkflowDisplayContext") -> JsonArray:
+        """Serialize node attributes, skipping unserializable ones."""
+        attributes: JsonArray = []
+        for attribute in self._node:
+            if attribute in self.__unserializable_attributes__:
+                continue
+
+            id = (
+                str(self.attribute_ids_by_name[attribute.name])
+                if self.attribute_ids_by_name.get(attribute.name)
+                else str(uuid4_from_hash(f"{self.node_id}|{attribute.name}"))
+            )
+            try:
+                attribute_dict: JsonObject = {
+                    "id": id,
+                    "name": attribute.name,
+                    "value": serialize_value(display_context, attribute.instance),
+                }
+                attributes.append(attribute_dict)
+            except ValueError as e:
+                raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
+
+        return attributes
+
     def get_base(self) -> CodeResourceDefinition:
         node = self._node
 

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_ee/workflows/display/nodes/vellum/api_node.py

@@ -31,6 +31,19 @@ class BaseAPINodeDisplay(BaseNodeDisplay[_APINodeType], Generic[_APINodeType]):
         APINode.authorization_type,
     }
 
+    # TODO: Only serialize attributes not inputs
+    __unserializable_attributes__ = {
+        APINode.data,
+        APINode.url,
+        APINode.method,
+        APINode.json,
+        APINode.headers,
+        APINode.api_key_header_key,
+        APINode.api_key_header_value,
+        APINode.bearer_token_value,
+        APINode.authorization_type,
+    }
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
@@ -171,7 +184,7 @@ class BaseAPINodeDisplay(BaseNodeDisplay[_APINodeType], Generic[_APINodeType]):
             cast(OutputReference, node.Outputs.status_code)
         ]
 
-        return {
+        serialized_node: JsonObject = {
             "id": str(node_id),
             "type": "API",
             "inputs": [input.dict() for input in inputs],
@@ -205,3 +218,9 @@ class BaseAPINodeDisplay(BaseNodeDisplay[_APINodeType], Generic[_APINodeType]):
             "definition": self.get_definition().dict(),
             "ports": self.serialize_ports(display_context),
         }
+
+        attributes = self._serialize_attributes(display_context)
+        if attributes:
+            serialized_node["attributes"] = attributes
+
+        return serialized_node

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -11,7 +11,6 @@ from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 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.utils.expressions import serialize_value
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 from vellum_ee.workflows.display.vellum import NodeInput
 
@@ -173,7 +172,6 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
             }
 
         elif prompt_block.block_type == "CHAT_MESSAGE":
-
             chat_properties: JsonObject = {
                 "chat_role": prompt_block.chat_role,
                 "chat_source": prompt_block.chat_source,
@@ -248,30 +246,6 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
 
         return block
 
-    def _serialize_attributes(self, display_context: "WorkflowDisplayContext"):
-        attributes = []
-        for attribute in self._node:
-            if attribute in self.__unserializable_attributes__:
-                continue
-
-            id = (
-                str(self.attribute_ids_by_name[attribute.name])
-                if self.attribute_ids_by_name.get(attribute.name)
-                else str(uuid4_from_hash(f"{self.node_id}|{attribute.name}"))
-            )
-            try:
-                attributes.append(
-                    {
-                        "id": id,
-                        "name": attribute.name,
-                        "value": serialize_value(display_context, attribute.instance),
-                    }
-                )
-            except ValueError as e:
-                raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
-
-        return attributes
-
     def _serialize_parameters(self, parameters, display_context: "WorkflowDisplayContext") -> JsonObject:
         """Serialize parameters, returning empty object when nested descriptors are detected."""
         params = raise_if_descriptor(parameters)

vellum_ai-1.0.1/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_api_node.py

@@ -0,0 +1,31 @@
+from vellum.workflows.constants import APIRequestMethod
+from vellum.workflows.nodes.displayable.api_node.node import APINode
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_serialize_node__api_node_with_timeout():
+    # GIVEN an API node with timeout specified
+    class MyAPINode(APINode):
+        url = "https://api.example.com"
+        method = APIRequestMethod.GET
+        timeout = 30  # This is the key attribute we're testing
+
+    # AND a workflow with the API node
+    class Workflow(BaseWorkflow):
+        graph = MyAPINode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the timeout
+    my_api_node = next(node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "API")
+
+    # Assert that timeout is present in the serialized attributes
+    timeout_attribute = next((attr for attr in my_api_node.get("attributes", []) if attr["name"] == "timeout"), None)
+
+    assert timeout_attribute is not None, "timeout attribute should be present in serialized attributes"
+    assert timeout_attribute["value"]["type"] == "CONSTANT_VALUE"
+    assert timeout_attribute["value"]["value"]["type"] == "NUMBER"
+    assert timeout_attribute["value"]["value"]["value"] == 30.0

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_api_node_serialization.py

@@ -162,6 +162,16 @@ def test_serialize_workflow(vellum_client):
                     },
                 },
             ],
+            "attributes": [
+                {
+                    "id": "ad719e65-0032-4012-a0bd-9b5162194bce",
+                    "name": "timeout",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {"type": "JSON", "value": None},
+                    },
+                },
+            ],
             "data": {
                 "label": "Simple A P I Node",
                 "error_output_id": None,

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -407,6 +407,27 @@ def test_serialize_workflow():
                     ],
                 },
             },
+            {
+                "id": "229cd1ca-dc2f-4586-b933-c4d4966f7bd1",
+                "name": "parameters",
+                "value": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "JSON",
+                        "value": {
+                            "stop": [],
+                            "temperature": 0.0,
+                            "max_tokens": 4096.0,
+                            "top_p": 1.0,
+                            "top_k": 0.0,
+                            "frequency_penalty": 0.0,
+                            "presence_penalty": 0.0,
+                            "logit_bias": None,
+                            "custom_parameters": None,
+                        },
+                    },
+                },
+            },
             {
                 "id": "1668419e-a193-43a5-8a97-3394e89bf278",
                 "name": "max_prompt_iterations",

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -169,6 +169,27 @@ def test_serialize_workflow():
                     ],
                 },
             },
+            {
+                "id": "229cd1ca-dc2f-4586-b933-c4d4966f7bd1",
+                "name": "parameters",
+                "value": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "JSON",
+                        "value": {
+                            "stop": [],
+                            "temperature": 0.0,
+                            "max_tokens": 4096.0,
+                            "top_p": 1.0,
+                            "top_k": 0.0,
+                            "frequency_penalty": 0.0,
+                            "presence_penalty": 0.0,
+                            "logit_bias": None,
+                            "custom_parameters": None,
+                        },
+                    },
+                },
+            },
             {
                 "id": "1668419e-a193-43a5-8a97-3394e89bf278",
                 "name": "max_prompt_iterations",

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -136,13 +136,19 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 if workflow_input_reference.instance
                 else None
             )
+
+            # An input is required if it has no default value AND is not optional
+            has_default = workflow_input_reference.instance is not undefined
+            is_optional = type(None) in workflow_input_reference.types
+            is_required = not has_default and not is_optional
+
             input_variables.append(
                 {
                     "id": str(workflow_input_display.id),
                     "key": workflow_input_display.name or workflow_input_reference.name,
                     "type": infer_vellum_variable_type(workflow_input_reference),
                     "default": default.dict() if default else None,
-                    "required": workflow_input_reference.instance is undefined,
+                    "required": is_required,
                     "extensions": {"color": workflow_input_display.color},
                 }
             )
@@ -152,13 +158,19 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             default = (
                 primitive_to_vellum_value(state_value_reference.instance) if state_value_reference.instance else None
             )
+
+            # A state variable is required if it has no default value AND is not optional
+            has_default = state_value_reference.instance is not undefined
+            is_optional = type(None) in state_value_reference.types
+            is_required = not has_default and not is_optional
+
             state_variables.append(
                 {
                     "id": str(state_value_display.id),
                     "key": state_value_display.name or state_value_reference.name,
                     "type": infer_vellum_variable_type(state_value_reference),
                     "default": default.dict() if default else None,
-                    "required": state_value_reference.instance is undefined,
+                    "required": is_required,
                     "extensions": {"color": state_value_display.color},
                 }
             )

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/ee/vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -1,6 +1,8 @@
 import pytest
 from uuid import uuid4
+from typing import Optional
 
+from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
@@ -8,6 +10,7 @@ from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.nodes.displayable.final_output_node.node import FinalOutputNode
 from vellum.workflows.references.lazy import LazyReference
+from vellum.workflows.state.base import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
 from vellum_ee.workflows.display.nodes import BaseNodeDisplay
@@ -828,3 +831,127 @@ def test_serialize_workflow__empty_rules_indexerror():
     terminal_nodes = [node for node in nodes if node.get("type") == "TERMINAL"]
     assert len(terminal_nodes) == 1
     assert terminal_nodes[0]["data"]["name"] == "problematic_output"
+
+
+def test_serialize_workflow__input_variables():
+    # GIVEN a workflow with inputs
+    class Inputs(BaseInputs):
+        input_1: str
+        input_2: Optional[str]
+        input_3: int = 1
+        input_4: Optional[int] = 2
+
+    class MyWorkflow(BaseWorkflow[Inputs, BaseState]):
+        pass
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data = workflow_display.serialize()
+
+    # THEN the inputs should be serialized correctly
+    assert "input_variables" in data
+    input_variables = data["input_variables"]
+    assert isinstance(input_variables, list)
+    assert len(input_variables) == 4
+
+    input_1 = next(var for var in input_variables if isinstance(var, dict) and var["key"] == "input_1")
+    assert input_1 == {
+        "id": "13bd7980-3fbd-486c-9ebd-a29d84f7bda0",
+        "key": "input_1",
+        "type": "STRING",
+        "default": None,
+        "required": True,
+        "extensions": {"color": None},
+    }
+
+    input_2 = next(var for var in input_variables if isinstance(var, dict) and var["key"] == "input_2")
+    assert input_2 == {
+        "id": "13847952-beab-408d-945e-cfa079e6e124",
+        "key": "input_2",
+        "type": "STRING",
+        "default": None,
+        "required": False,
+        "extensions": {"color": None},
+    }
+
+    input_3 = next(var for var in input_variables if isinstance(var, dict) and var["key"] == "input_3")
+    assert input_3 == {
+        "id": "2e38e1a4-09ff-4bb8-a12e-9bf54d4f3a5e",
+        "key": "input_3",
+        "type": "NUMBER",
+        "default": {"type": "NUMBER", "value": 1.0},
+        "required": False,
+        "extensions": {"color": None},
+    }
+
+    input_4 = next(var for var in input_variables if isinstance(var, dict) and var["key"] == "input_4")
+    assert input_4 == {
+        "id": "d945b6ae-2490-4bfb-9b1c-b1e484dfd4f6",
+        "key": "input_4",
+        "type": "NUMBER",
+        "default": {"type": "NUMBER", "value": 2.0},
+        "required": False,
+        "extensions": {"color": None},
+    }
+
+
+def test_serialize_workflow__state_variables():
+    # GIVEN a workflow with state variables
+    class State(BaseState):
+        state_1: str = "hello"
+        state_2: Optional[str] = None
+        state_3: int = 1
+        state_4: Optional[int] = 2
+
+    class MyWorkflow(BaseWorkflow[BaseInputs, State]):
+        pass
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data = workflow_display.serialize()
+
+    # THEN the state variables should be serialized correctly
+    assert "state_variables" in data
+    state_variables = data["state_variables"]
+    assert isinstance(state_variables, list)
+    assert len(state_variables) == 4
+
+    state_1 = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "state_1")
+    assert state_1 == {
+        "id": "83c5b71d-56eb-42a5-84df-97e3591370c2",
+        "key": "state_1",
+        "type": "STRING",
+        "default": {"type": "STRING", "value": "hello"},
+        "required": False,
+        "extensions": {"color": None},
+    }
+
+    state_2 = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "state_2")
+    assert state_2 == {
+        "id": "9b0cfeec-aa66-42b3-8f31-aa7eb8ac30ea",
+        "key": "state_2",
+        "type": "STRING",
+        "default": None,
+        "required": False,
+        "extensions": {"color": None},
+    }
+
+    state_3 = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "state_3")
+    assert state_3 == {
+        "id": "3e19c570-6b46-4eab-ad81-d8d97028496f",
+        "key": "state_3",
+        "type": "NUMBER",
+        "default": {"type": "NUMBER", "value": 1.0},
+        "required": False,
+        "extensions": {"color": None},
+    }
+
+    state_4 = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "state_4")
+    assert state_4 == {
+        "id": "50c735de-f269-4d0a-b511-c9a1104451bb",
+        "key": "state_4",
+        "type": "NUMBER",
+        "default": {"type": "NUMBER", "value": 2.0},
+        "required": False,
+        "extensions": {"color": None},
+    }

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/pyproject.toml

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

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/src/vellum/__init__.py

@@ -287,6 +287,7 @@ from .client.types import (
     OpenAiVectorizerTextEmbedding3SmallRequest,
     OpenAiVectorizerTextEmbeddingAda002,
     OpenAiVectorizerTextEmbeddingAda002Request,
+    OrganizationLimitConfig,
     OrganizationRead,
     PaginatedContainerImageReadList,
     PaginatedDeploymentReleaseTagReadList,
@@ -327,6 +328,7 @@ from .client.types import (
     PromptRequestStringInput,
     PromptSettings,
     PromptVersionBuildConfigSandbox,
+    Quota,
     RawPromptExecutionOverridesRequest,
     ReductoChunkerConfig,
     ReductoChunkerConfigRequest,
@@ -524,6 +526,7 @@ from .client.types import (
     VellumVariableExtensions,
     VellumVariableType,
     VellumWorkflowExecutionEvent,
+    VembdaServiceTierEnum,
     WorkflowDeploymentEventExecutionsResponse,
     WorkflowDeploymentHistoryItem,
     WorkflowDeploymentParentContext,
@@ -932,6 +935,7 @@ __all__ = [
     "OpenAiVectorizerTextEmbedding3SmallRequest",
     "OpenAiVectorizerTextEmbeddingAda002",
     "OpenAiVectorizerTextEmbeddingAda002Request",
+    "OrganizationLimitConfig",
     "OrganizationRead",
     "PaginatedContainerImageReadList",
     "PaginatedDeploymentReleaseTagReadList",
@@ -972,6 +976,7 @@ __all__ = [
     "PromptRequestStringInput",
     "PromptSettings",
     "PromptVersionBuildConfigSandbox",
+    "Quota",
     "RawPromptExecutionOverridesRequest",
     "ReductoChunkerConfig",
     "ReductoChunkerConfigRequest",
@@ -1171,6 +1176,7 @@ __all__ = [
     "VellumVariableExtensions",
     "VellumVariableType",
     "VellumWorkflowExecutionEvent",
+    "VembdaServiceTierEnum",
     "WorkflowDeploymentEventExecutionsResponse",
     "WorkflowDeploymentHistoryItem",
     "WorkflowDeploymentParentContext",

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/src/vellum/client/core/client_wrapper.py

@@ -25,10 +25,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.0.0",
+            "User-Agent": "vellum-ai/1.0.1",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.0.0",
+            "X-Fern-SDK-Version": "1.0.1",
         }
         if self._api_version is not None:
             headers["X-API-Version"] = self._api_version

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/src/vellum/client/types/__init__.py

@@ -295,6 +295,7 @@ from .open_ai_vectorizer_text_embedding_3_small import OpenAiVectorizerTextEmbed
 from .open_ai_vectorizer_text_embedding_3_small_request import OpenAiVectorizerTextEmbedding3SmallRequest
 from .open_ai_vectorizer_text_embedding_ada_002 import OpenAiVectorizerTextEmbeddingAda002
 from .open_ai_vectorizer_text_embedding_ada_002_request import OpenAiVectorizerTextEmbeddingAda002Request
+from .organization_limit_config import OrganizationLimitConfig
 from .organization_read import OrganizationRead
 from .paginated_container_image_read_list import PaginatedContainerImageReadList
 from .paginated_deployment_release_tag_read_list import PaginatedDeploymentReleaseTagReadList
@@ -335,6 +336,7 @@ from .prompt_request_json_input import PromptRequestJsonInput
 from .prompt_request_string_input import PromptRequestStringInput
 from .prompt_settings import PromptSettings
 from .prompt_version_build_config_sandbox import PromptVersionBuildConfigSandbox
+from .quota import Quota
 from .raw_prompt_execution_overrides_request import RawPromptExecutionOverridesRequest
 from .reducto_chunker_config import ReductoChunkerConfig
 from .reducto_chunker_config_request import ReductoChunkerConfigRequest
@@ -548,6 +550,7 @@ from .vellum_variable import VellumVariable
 from .vellum_variable_extensions import VellumVariableExtensions
 from .vellum_variable_type import VellumVariableType
 from .vellum_workflow_execution_event import VellumWorkflowExecutionEvent
+from .vembda_service_tier_enum import VembdaServiceTierEnum
 from .workflow_deployment_event_executions_response import WorkflowDeploymentEventExecutionsResponse
 from .workflow_deployment_history_item import WorkflowDeploymentHistoryItem
 from .workflow_deployment_parent_context import WorkflowDeploymentParentContext
@@ -912,6 +915,7 @@ __all__ = [
     "OpenAiVectorizerTextEmbedding3SmallRequest",
     "OpenAiVectorizerTextEmbeddingAda002",
     "OpenAiVectorizerTextEmbeddingAda002Request",
+    "OrganizationLimitConfig",
     "OrganizationRead",
     "PaginatedContainerImageReadList",
     "PaginatedDeploymentReleaseTagReadList",
@@ -952,6 +956,7 @@ __all__ = [
     "PromptRequestStringInput",
     "PromptSettings",
     "PromptVersionBuildConfigSandbox",
+    "Quota",
     "RawPromptExecutionOverridesRequest",
     "ReductoChunkerConfig",
     "ReductoChunkerConfigRequest",
@@ -1149,6 +1154,7 @@ __all__ = [
     "VellumVariableExtensions",
     "VellumVariableType",
     "VellumWorkflowExecutionEvent",
+    "VembdaServiceTierEnum",
     "WorkflowDeploymentEventExecutionsResponse",
     "WorkflowDeploymentHistoryItem",
     "WorkflowDeploymentParentContext",

vellum_ai-1.0.1/src/vellum/client/types/organization_limit_config.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .vembda_service_tier_enum import VembdaServiceTierEnum
+from .quota import Quota
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class OrganizationLimitConfig(UniversalBaseModel):
+    vembda_service_tier: typing.Optional[VembdaServiceTierEnum] = None
+    prompt_executions_quota: typing.Optional[Quota] = None
+    workflow_executions_quota: typing.Optional[Quota] = None
+    workflow_runtime_seconds_quota: typing.Optional[Quota] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/src/vellum/client/types/organization_read.py

@@ -3,6 +3,7 @@
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
 from .new_member_join_behavior_enum import NewMemberJoinBehaviorEnum
+from .organization_limit_config import OrganizationLimitConfig
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -12,6 +13,7 @@ class OrganizationRead(UniversalBaseModel):
     name: str
     allow_staff_access: typing.Optional[bool] = None
     new_member_join_behavior: NewMemberJoinBehaviorEnum
+    limit_config: OrganizationLimitConfig
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum_ai-1.0.1/src/vellum/client/types/quota.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class Quota(UniversalBaseModel):
+    name: str
+    value: typing.Optional[int] = None
+    period_seconds: typing.Optional[int] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum_ai-1.0.1/src/vellum/client/types/vembda_service_tier_enum.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+VembdaServiceTierEnum = typing.Union[typing.Literal["FREE", "PAID"], typing.Any]

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/src/vellum/client/types/workflow_execution_actual.py

@@ -12,7 +12,7 @@ import pydantic
 class WorkflowExecutionActual(UniversalBaseModel):
     output: ExecutionVellumValue
     timestamp: dt.datetime
-    quality: float
+    quality: typing.Optional[float] = None
     metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
 
     if IS_PYDANTIC_V2:

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

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

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

{vellum_ai-1.0.0 → vellum_ai-1.0.1}/src/vellum/workflows/nodes/displayable/api_node/node.py

@@ -65,4 +65,5 @@ class APINode(BaseAPINode):
             json=self.json,
             headers=final_headers,
             bearer_token=bearer_token,
+            timeout=self.timeout,
         )