vellum-ai 0.14.89__py3-none-any.whl → 1.0.0__py3-none-any.whl

vellum/__init__.py

@@ -3,7 +3,7 @@ from .plugins.utils import load_runtime_plugins
 
 load_runtime_plugins()
 
-from .types import (
+from .client.types import (
     AdHocExecutePromptEvent,
     AdHocExpandMeta,
     AdHocFulfilledPromptExecutionMeta,

vellum/client/__init__.py

@@ -128,7 +128,7 @@ class Vellum:
         self,
         *,
         environment: VellumEnvironment = VellumEnvironment.PRODUCTION,
-        api_version: typing.Optional[ApiVersionEnum] = os.getenv("VELLUM_API_VERSION", "2024-10-25"),
+        api_version: typing.Optional[ApiVersionEnum] = os.getenv("VELLUM_API_VERSION", "2025-07-30"),
         api_key: str,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
@@ -1562,7 +1562,7 @@ class AsyncVellum:
         self,
         *,
         environment: VellumEnvironment = VellumEnvironment.PRODUCTION,
-        api_version: typing.Optional[ApiVersionEnum] = os.getenv("VELLUM_API_VERSION", "2024-10-25"),
+        api_version: typing.Optional[ApiVersionEnum] = os.getenv("VELLUM_API_VERSION", "2025-07-30"),
         api_key: str,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,

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/0.14.89",
+            "User-Agent": "vellum-ai/1.0.0",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.89",
+            "X-Fern-SDK-Version": "1.0.0",
         }
         if self._api_version is not None:
             headers["X-API-Version"] = self._api_version

vellum/evaluations/resources.py

@@ -8,11 +8,7 @@ from typing import Callable, Generator, Iterable, List, cast
 
 from vellum import TestSuiteRunMetricNumberOutput, TestSuiteRunRead
 from vellum.client import OMIT, Vellum
-from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAULT_POLLING_INTERVAL_MS
-from vellum.evaluations.exceptions import TestSuiteRunResultsException
-from vellum.evaluations.utils.env import get_api_key
-from vellum.evaluations.utils.paginator import PaginatedResults, get_all_results
-from vellum.types import (
+from vellum.client.types import (
     ExternalTestCaseExecutionRequest,
     NamedTestCaseVariableValueRequest,
     TestCaseVariableValue,
@@ -22,6 +18,10 @@ from vellum.types import (
     TestSuiteRunMetricOutput,
     TestSuiteRunState,
 )
+from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAULT_POLLING_INTERVAL_MS
+from vellum.evaluations.exceptions import TestSuiteRunResultsException
+from vellum.evaluations.utils.env import get_api_key
+from vellum.evaluations.utils.paginator import PaginatedResults, get_all_results
 from vellum.utils.typing import cast_not_optional
 from vellum.utils.uuid import is_valid_uuid
 

vellum/workflows/events/node.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Any, Dict, Generic, List, Literal, Optional, S
 
 from pydantic import SerializerFunctionWrapHandler, field_serializer, model_serializer
 
-from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.errors import WorkflowError
 from vellum.workflows.expressions.accessor import AccessorExpression
 from vellum.workflows.outputs.base import BaseOutput

vellum/workflows/events/types.py

@@ -6,7 +6,7 @@ from typing import Annotated, Any, Literal, Optional, Union, get_args
 from pydantic import Field, GetCoreSchemaHandler, Tag, ValidationInfo
 from pydantic_core import CoreSchema, core_schema
 
-from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.definition import VellumCodeResourceDefinition
 from vellum.workflows.types.utils import datetime_now

vellum/workflows/events/workflow.py

@@ -4,7 +4,7 @@ from typing_extensions import TypeGuard
 
 from pydantic import field_serializer
 
-from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.errors import WorkflowError
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -2,8 +2,8 @@ import pytest
 from uuid import UUID
 from typing import Optional, Set
 
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
-from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.tests.test_utils import FixtureState
 from vellum.workflows.inputs.base import BaseInputs

vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -2,8 +2,8 @@ from abc import abstractmethod
 from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union
 
 from vellum import AdHocExecutePromptEvent, ExecutePromptEvent, PromptOutput
+from vellum.client.core import RequestOptions
 from vellum.client.core.api_error import ApiError
-from vellum.core import RequestOptions
 from vellum.workflows.errors.types import WorkflowErrorCode, vellum_error_to_workflow_error
 from vellum.workflows.events.node import NodeExecutionStreamingEvent
 from vellum.workflows.exceptions import NodeException

vellum/workflows/nodes/displayable/bases/search_node.py

@@ -11,7 +11,7 @@ from vellum import (
     SearchResultMergingRequest,
     SearchWeightsRequest,
 )
-from vellum.core import ApiError, RequestOptions
+from vellum.client.core import ApiError, RequestOptions
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode

vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -20,9 +20,9 @@ from vellum import (
     VellumError,
     VellumValue,
 )
+from vellum.client.core import RequestOptions
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
-from vellum.core import RequestOptions
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode

vellum/workflows/nodes/displayable/guardrail_node/node.py

@@ -3,7 +3,7 @@ from typing import Any, ClassVar, Dict, Generic, List, Optional, Union, cast
 
 from vellum import ChatHistoryInput, ChatMessage, JsonInput, MetricDefinitionInput, NumberInput, StringInput
 from vellum.client import ApiError
-from vellum.core import RequestOptions
+from vellum.client.core import RequestOptions
 from vellum.workflows.constants import LATEST_RELEASE_TAG
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException

vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py

@@ -12,9 +12,9 @@ from vellum import (
     WorkflowRequestNumberInputRequest,
     WorkflowRequestStringInputRequest,
 )
+from vellum.client.core import RequestOptions
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.chat_message_request import ChatMessageRequest
-from vellum.core import RequestOptions
 from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
 from vellum.workflows.context import get_execution_context
 from vellum.workflows.errors import WorkflowErrorCode

vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Iterator, List, Optional, Type, cast
+from typing import Any, Callable, Iterator, List, Optional, Type, cast
 
 from pydash import snake_case
 
@@ -9,33 +9,26 @@ from vellum.client.types.function_call_chat_message_content_value import Functio
 from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.string_chat_message_content import StringChatMessageContent
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
-from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
-from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
 from vellum.workflows.nodes.displayable.subworkflow_deployment_node.node import SubworkflowDeploymentNode
 from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
-from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
-from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.state import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool
 from vellum.workflows.types.definition import DeploymentDefinition
 from vellum.workflows.types.generics import is_workflow_class
-from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 CHAT_HISTORY_VARIABLE = "chat_history"
 
 
-class FunctionNode(BaseNode):
-    """Node that executes a specific function."""
-
-    pass
-
-
 class ToolRouterNode(InlinePromptNode[ToolCallingState]):
     max_prompt_iterations: Optional[int] = 5
 
@@ -120,6 +113,76 @@ class DynamicSubworkflowDeploymentNode(SubworkflowDeploymentNode[ToolCallingStat
         )
 
 
+class DynamicInlineSubworkflowNode(InlineSubworkflowNode[ToolCallingState, BaseInputs, BaseState]):
+    """Node that executes an inline subworkflow with function call output."""
+
+    function_call_output: List[PromptOutput]
+
+    def run(self) -> Iterator[BaseOutput]:
+        if self.function_call_output and len(self.function_call_output) > 0:
+            function_call = self.function_call_output[0]
+            if function_call.type == "FUNCTION_CALL" and function_call.value is not None:
+                arguments = function_call.value.arguments
+            else:
+                arguments = {}
+        else:
+            arguments = {}
+
+        self.subworkflow_inputs = arguments  # type: ignore[misc]
+
+        # Call the parent run method to execute the subworkflow with proper streaming
+        outputs = {}
+
+        for output in super().run():
+            if output.is_fulfilled:
+                outputs[output.name] = output.value
+            yield output
+
+        # Add the result to the chat history
+        self.state.chat_history.append(
+            ChatMessage(
+                role="FUNCTION",
+                content=StringChatMessageContent(value=json.dumps(outputs, cls=DefaultStateEncoder)),
+            )
+        )
+
+
+class FunctionNode(BaseNode[ToolCallingState]):
+    """Node that executes a regular Python function with function call output."""
+
+    function_call_output: List[PromptOutput]
+    function_definition: Callable[..., Any]
+
+    def run(self) -> Iterator[BaseOutput]:
+        if self.function_call_output and len(self.function_call_output) > 0:
+            function_call = self.function_call_output[0]
+            if function_call.type == "FUNCTION_CALL" and function_call.value is not None:
+                arguments = function_call.value.arguments
+            else:
+                arguments = {}
+        else:
+            arguments = {}
+
+        try:
+            result = self.function_definition(**arguments)
+        except Exception as e:
+            function_name = self.function_definition.__name__
+            raise NodeException(
+                message=f"Error executing function '{function_name}': {str(e)}",
+                code=WorkflowErrorCode.NODE_EXECUTION,
+            )
+
+        # Add the result to the chat history
+        self.state.chat_history.append(
+            ChatMessage(
+                role="FUNCTION",
+                content=StringChatMessageContent(value=json.dumps(result, cls=DefaultStateEncoder)),
+            )
+        )
+
+        yield from []
+
+
 def create_tool_router_node(
     ml_model: str,
     blocks: List[PromptBlock],
@@ -191,7 +254,7 @@ def create_tool_router_node(
 def create_function_node(
     function: Tool,
     tool_router_node: Type[ToolRouterNode],
-) -> Type[FunctionNode]:
+) -> Type[BaseNode]:
     """
     Create a FunctionNode class for a given function.
 
@@ -220,117 +283,23 @@ def create_function_node(
         return node
 
     elif is_workflow_class(function):
-        # Create a class-level wrapper that calls the original function
-        def execute_inline_workflow_function(self) -> BaseNode.Outputs:
-            function_call_output = self.state.meta.node_outputs.get(tool_router_node.Outputs.results)
-            if function_call_output and len(function_call_output) > 0:
-                function_call = function_call_output[0]
-                arguments = function_call.value.arguments
-            else:
-                arguments = {}
-
-            # Call the function based on its type
-            inputs_instance = function.get_inputs_class()(**arguments)
-
-            with execution_context(parent_context=get_parent_context()):
-                workflow = function(
-                    parent_state=self.state,
-                    context=WorkflowContext.create_from(self._context),
-                )
-                subworkflow_stream = workflow.stream(
-                    inputs=inputs_instance,
-                    event_filter=all_workflow_event_filter,
-                    node_output_mocks=self._context._get_all_node_output_mocks(),
-                )
-
-            outputs: Optional[BaseOutputs] = None
-            exception: Optional[NodeException] = None
-
-            for event in subworkflow_stream:
-                self._context._emit_subworkflow_event(event)
-                if exception:
-                    continue
-
-                if not is_workflow_event(event):
-                    continue
-                if event.workflow_definition != function:
-                    continue
-
-                if event.name == "workflow.execution.fulfilled":
-                    outputs = event.outputs
-                elif event.name == "workflow.execution.rejected":
-                    exception = NodeException.of(event.error)
-                elif event.name == "workflow.execution.paused":
-                    exception = NodeException(
-                        code=WorkflowErrorCode.INVALID_OUTPUTS,
-                        message="Subworkflow unexpectedly paused",
-                    )
-
-            if exception:
-                raise exception
-
-            if outputs is None:
-                raise NodeException(
-                    message="Expected to receive outputs from inline subworkflow",
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                )
-
-            result = outputs
-
-            self.state.chat_history.append(
-                ChatMessage(
-                    role="FUNCTION",
-                    content=StringChatMessageContent(value=json.dumps(result, cls=DefaultStateEncoder)),
-                )
-            )
-
-            return self.Outputs()
-
-        # Create BaseNode for workflow functions
         node = type(
-            f"InlineWorkflowNode_{function.__name__}",
-            (FunctionNode,),
+            f"DynamicInlineSubworkflowNode_{function.__name__}",
+            (DynamicInlineSubworkflowNode,),
             {
-                "run": execute_inline_workflow_function,
+                "subworkflow": function,
+                "function_call_output": tool_router_node.Outputs.results,
                 "__module__": __name__,
             },
         )
     else:
-        # For regular functions, call them directly
-        def execute_regular_function(self) -> BaseNode.Outputs:
-            # Get the function call from the tool router output
-            function_call_output = self.state.meta.node_outputs.get(tool_router_node.Outputs.results)
-            if function_call_output and len(function_call_output) > 0:
-                function_call = function_call_output[0]
-                arguments = function_call.value.arguments
-            else:
-                arguments = {}
-
-            # Call the function directly
-            try:
-                result = function(**arguments)
-            except Exception as e:
-                raise NodeException(
-                    message=f"Error executing function '{function.__name__}': {str(e)}",
-                    code=WorkflowErrorCode.NODE_EXECUTION,
-                )
-
-            # Add the result to the chat history
-            self.state.chat_history.append(
-                ChatMessage(
-                    role="FUNCTION",
-                    content=StringChatMessageContent(value=json.dumps(result, cls=DefaultStateEncoder)),
-                )
-            )
-
-            return self.Outputs()
-
-        # Create BaseNode for regular functions
+        # For regular functions, use FunctionNode
         node = type(
             f"FunctionNode_{function.__name__}",
             (FunctionNode,),
             {
-                "run": execute_regular_function,
+                "function_definition": lambda self, **kwargs: function(**kwargs),
+                "function_call_output": tool_router_node.Outputs.results,
                 "__module__": __name__,
             },
         )

vellum/workflows/nodes/experimental/__init__.py

@@ -1,3 +1,3 @@
-from ..displayable.tool_calling_node import ToolCallingNode
+from .openai_chat_completion_node import OpenAIChatCompletionNode
 
-__all__ = ["ToolCallingNode"]
+__all__ = ["OpenAIChatCompletionNode"]

vellum/workflows/state/base.py

@@ -27,7 +27,7 @@ from typing_extensions import dataclass_transform
 from pydantic import GetCoreSchemaHandler, ValidationInfo, field_serializer, field_validator
 from pydantic_core import core_schema
 
-from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.constants import undefined
 from vellum.workflows.inputs.base import BaseInputs

vellum/workflows/state/delta.py

@@ -1,6 +1,6 @@
 from typing import Any, Literal, Union
 
-from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 
 
 class BaseStateDelta(UniversalBaseModel):

{vellum_ai-0.14.89.dist-info → vellum_ai-1.0.0.dist-info}/METADATA

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