vellum-ai 0.14.21__tar.gz → 0.14.23__tar.gz

vellum_ai-0.14.23/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: vellum-ai
+Version: 0.14.23
+Summary: 
+License: MIT
+Requires-Python: >=3.9,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: Jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: cdktf (>=0.20.5,<0.21.0)
+Requires-Dist: click (==8.1.7)
+Requires-Dist: docker (==7.1.0)
+Requires-Dist: httpx (>=0.21.2)
+Requires-Dist: openai (>=1.0.0)
+Requires-Dist: orderly-set (>=5.2.2,<6.0.0)
+Requires-Dist: publication (==0.0.3)
+Requires-Dist: pydantic (>=1.9.2)
+Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
+Requires-Dist: pydash (==7.0.6)
+Requires-Dist: python-dotenv (==1.0.1)
+Requires-Dist: pytz (==2025.1)
+Requires-Dist: pyyaml (==6.0.2)
+Requires-Dist: requests (==2.32.3)
+Requires-Dist: tomli (==2.0.2)
+Requires-Dist: typing_extensions (>=4.0.0)
+Project-URL: Repository, https://github.com/vellum-ai/vellum-python-sdks
+Description-Content-Type: text/markdown
+
+<p align="center">
+   <a href="https://vellum.ai">
+    <picture>
+      <img alt="Vellum README banner" src="https://storage.googleapis.com/vellum-public/assets/github-readme-banner.png" height="128">
+    </picture>
+  </a>
+  <p align="center">
+    <a href="https://vellum.ai">Learn more</a>
+    ·
+    <a href="https://www.vellum.ai/landing-pages/request-demo">Talk to us</a>
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://pepy.tech/project/vellum-ai">
+    <img src="https://img.shields.io/pypi/dm/vellum-ai" alt="Vellum AI PyPI - Downloads" >
+  </a>
+  <a href="https://pypi.org/project/vellum-ai" target="_blank">
+    <img src="https://img.shields.io/pypi/v/vellum-ai?color=%2334D058&label=pypi%20package" alt="Package version">
+  </a>
+  <a href="https://www.ycombinator.com/companies/vellum">
+    <img src="https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square" alt="Y Combinator S24">
+  </a>
+</p>
+
+# Introduction
+
+[Vellum](https://www.vellum.ai/) is the end-to-end development platform for building production-grade AI applications.
+
+### Core Features
+
+- **Orchestration:** A powerful SDK and IDE for defining and debugging the control flow of your AI applications
+- **Prompting:** A best-in-class prompt playground for iterating on and refining prompts between models from any provider
+- **Evaluations**: An evaluations framework that makes it easy to measure the quality of your AI systems at scale
+- **Retrieval:** A ready-to-go service for turning unstructured content into intelligent, context-aware solutions
+  optimized for AI systems
+- **Deployment:** Decouple updates to your AI systems from your application code with an easy integration +
+  one-click deploy
+- **Observability:** Monitor and debug your AI systems in real-time with detailed logs, metrics, and end-user feedback
+
+## Table of Contents
+
+- [Get Started](#get-started)
+- [Client SDK](#client-sdk)
+- [Workflows SDK](#workflows-sdk)
+- [Contributing](#contributing)
+- [Open-source vs paid](#open-source-vs-paid)
+
+## Get Started
+
+Most functionality within the Vellum SDK requires a Vellum account and API key. You can sign up for free [here](https://app.vellum.ai/signup?f=wsdk&utm_source=github&utm_medium=repo_readme&utm_campaign=sdk) or visit our [pricing page](https://www.vellum.ai/pricing) for paid options.
+
+Even without a Vellum account, you can use the Workflows SDK to define the control flow of your AI systems. [Learn
+more below](#workflows-sdk).
+
+## Client SDK
+
+The Vellum Client SDK, found within `src/vellum/client` is a low-level client used to interact directly with the Vellum API.
+Learn more and get started by visiting the [Vellum Client SDK README](/src/vellum/client/README.md).
+
+## Workflows SDK
+
+The Vellum Workflows SDK is a high-level framework for defining and debugging the control flow of AI systems. At
+it's core, it's a powerful workflow engine with syntactic sugar for declaratively defining graphs, the nodes within,
+and the relationships between them.
+
+The Workflows SDK can be used with or without a Vellum account, but a Vellum account is required to use certain
+out-of-box nodes and features, including the ability to push and pull your Workflow definition to Vellum for editing
+and debugging via a UI.
+
+To learn more and get started, visit the [Vellum Workflows SDK README](/src/vellum/workflows/README.md).
+
+## Contributing
+
+See the [CONTRIBUTING.md](/CONTRIBUTING.md) for information on how to contribute to the Vellum SDKs.
+
+## Open-Source vs. Paid
+
+This repo is available under the [MIT expat license](https://github.com/vellum-ai/vellum-python-sdks/blob/main/LICENSE), except
+for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.
+
+To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).
+

vellum_ai-0.14.23/README.md

@@ -0,0 +1,82 @@
+<p align="center">
+   <a href="https://vellum.ai">
+    <picture>
+      <img alt="Vellum README banner" src="https://storage.googleapis.com/vellum-public/assets/github-readme-banner.png" height="128">
+    </picture>
+  </a>
+  <p align="center">
+    <a href="https://vellum.ai">Learn more</a>
+    ·
+    <a href="https://www.vellum.ai/landing-pages/request-demo">Talk to us</a>
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://pepy.tech/project/vellum-ai">
+    <img src="https://img.shields.io/pypi/dm/vellum-ai" alt="Vellum AI PyPI - Downloads" >
+  </a>
+  <a href="https://pypi.org/project/vellum-ai" target="_blank">
+    <img src="https://img.shields.io/pypi/v/vellum-ai?color=%2334D058&label=pypi%20package" alt="Package version">
+  </a>
+  <a href="https://www.ycombinator.com/companies/vellum">
+    <img src="https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square" alt="Y Combinator S24">
+  </a>
+</p>
+
+# Introduction
+
+[Vellum](https://www.vellum.ai/) is the end-to-end development platform for building production-grade AI applications.
+
+### Core Features
+
+- **Orchestration:** A powerful SDK and IDE for defining and debugging the control flow of your AI applications
+- **Prompting:** A best-in-class prompt playground for iterating on and refining prompts between models from any provider
+- **Evaluations**: An evaluations framework that makes it easy to measure the quality of your AI systems at scale
+- **Retrieval:** A ready-to-go service for turning unstructured content into intelligent, context-aware solutions
+  optimized for AI systems
+- **Deployment:** Decouple updates to your AI systems from your application code with an easy integration +
+  one-click deploy
+- **Observability:** Monitor and debug your AI systems in real-time with detailed logs, metrics, and end-user feedback
+
+## Table of Contents
+
+- [Get Started](#get-started)
+- [Client SDK](#client-sdk)
+- [Workflows SDK](#workflows-sdk)
+- [Contributing](#contributing)
+- [Open-source vs paid](#open-source-vs-paid)
+
+## Get Started
+
+Most functionality within the Vellum SDK requires a Vellum account and API key. You can sign up for free [here](https://app.vellum.ai/signup?f=wsdk&utm_source=github&utm_medium=repo_readme&utm_campaign=sdk) or visit our [pricing page](https://www.vellum.ai/pricing) for paid options.
+
+Even without a Vellum account, you can use the Workflows SDK to define the control flow of your AI systems. [Learn
+more below](#workflows-sdk).
+
+## Client SDK
+
+The Vellum Client SDK, found within `src/vellum/client` is a low-level client used to interact directly with the Vellum API.
+Learn more and get started by visiting the [Vellum Client SDK README](/src/vellum/client/README.md).
+
+## Workflows SDK
+
+The Vellum Workflows SDK is a high-level framework for defining and debugging the control flow of AI systems. At
+it's core, it's a powerful workflow engine with syntactic sugar for declaratively defining graphs, the nodes within,
+and the relationships between them.
+
+The Workflows SDK can be used with or without a Vellum account, but a Vellum account is required to use certain
+out-of-box nodes and features, including the ability to push and pull your Workflow definition to Vellum for editing
+and debugging via a UI.
+
+To learn more and get started, visit the [Vellum Workflows SDK README](/src/vellum/workflows/README.md).
+
+## Contributing
+
+See the [CONTRIBUTING.md](/CONTRIBUTING.md) for information on how to contribute to the Vellum SDKs.
+
+## Open-Source vs. Paid
+
+This repo is available under the [MIT expat license](https://github.com/vellum-ai/vellum-python-sdks/blob/main/LICENSE), except
+for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.
+
+To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).

vellum_ai-0.14.23/ee/vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py

@@ -0,0 +1,134 @@
+import re
+import types
+from uuid import UUID
+from typing import Any, Callable, Dict, Generic, Optional, Type, TypeVar, cast
+
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
+from vellum.workflows.nodes.utils import get_wrapped_node
+from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum.workflows.types.utils import get_original_base
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+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
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+
+_BaseAdornmentNodeType = TypeVar("_BaseAdornmentNodeType", bound=BaseAdornmentNode)
+
+
+def _recursively_replace_wrapped_node(node_class: Type[BaseNode], wrapped_node_display_class: Type["BaseNodeDisplay"]):
+    if not issubclass(node_class, BaseAdornmentNode):
+        return
+
+    # We must edit the node display class to use __wrapped_node__ everywhere it
+    # references the adorned node class, which is three places:
+    wrapped_node_class = node_class.__wrapped_node__
+    if not wrapped_node_class:
+        raise ValueError(f"Node {node_class.__name__} must be used as an adornment with the `wrap` method.")
+
+    # 1. The node display class' parameterized type
+    original_base_node_display = get_original_base(wrapped_node_display_class)
+    original_base_node_display.__args__ = (wrapped_node_class,)
+    wrapped_node_display_class._node_display_registry[wrapped_node_class] = wrapped_node_display_class
+    wrapped_node_display_class.__annotate_node__()
+
+    # 2. The node display class' output displays
+    for old_output in node_class.Outputs:
+        new_output = getattr(wrapped_node_class.Outputs, old_output.name, None)
+        if new_output is None:
+            # If the adornment is adding a new output, such as TryNode adding an "error" output,
+            # we skip it, since it should not be included in the adorned node's output displays
+            wrapped_node_display_class.output_display.pop(old_output, None)
+            continue
+
+        if old_output not in wrapped_node_display_class.output_display:
+            # If the adorned node doesn't have an output display defined for this output, we define one
+            wrapped_node_display_class.output_display[new_output] = NodeOutputDisplay(
+                id=wrapped_node_class.__output_ids__[old_output.name],
+                name=old_output.name,
+            )
+        else:
+            wrapped_node_display_class.output_display[new_output] = wrapped_node_display_class.output_display.pop(
+                old_output
+            )
+
+    # 3. The node display class' port displays
+    old_ports = list(wrapped_node_display_class.port_displays.keys())
+    for old_port in old_ports:
+        new_port = getattr(wrapped_node_class.Ports, old_port.name)
+        wrapped_node_display_class.port_displays[new_port] = wrapped_node_display_class.port_displays.pop(old_port)
+
+    # Now we keep drilling down recursively
+    if (
+        issubclass(wrapped_node_display_class, BaseAdornmentNodeDisplay)
+        and wrapped_node_display_class.__wrapped_node_display__
+    ):
+        _recursively_replace_wrapped_node(
+            wrapped_node_class,
+            wrapped_node_display_class.__wrapped_node_display__,
+        )
+
+
+class BaseAdornmentNodeDisplay(BaseNodeVellumDisplay[_BaseAdornmentNodeType], Generic[_BaseAdornmentNodeType]):
+    __wrapped_node_display__: Optional[Type[BaseNodeDisplay]] = None
+
+    def serialize(
+        self,
+        display_context: "WorkflowDisplayContext",
+        **kwargs: Any,
+    ) -> dict:
+        node = self._node
+        adornment = cast(Optional[JsonObject], kwargs.get("adornment"))
+        get_additional_kwargs = cast(Optional[Callable[[UUID], dict]], kwargs.get("get_additional_kwargs"))
+
+        wrapped_node = get_wrapped_node(node)
+        if not wrapped_node:
+            raise NotImplementedError(
+                "Unable to serialize standalone adornment nodes. Please use adornment nodes as a decorator."
+            )
+
+        wrapped_node_display_class = get_node_display_class(BaseNodeDisplay, wrapped_node)
+        wrapped_node_display = wrapped_node_display_class()
+        additional_kwargs = get_additional_kwargs(wrapped_node_display.node_id) if get_additional_kwargs else {}
+        serialized_wrapped_node = wrapped_node_display.serialize(display_context, **kwargs, **additional_kwargs)
+
+        adornments = cast(JsonArray, serialized_wrapped_node.get("adornments")) or []
+        serialized_wrapped_node["adornments"] = adornments + [adornment] if adornment else adornments
+
+        return serialized_wrapped_node
+
+    @classmethod
+    def wrap(cls, node_id: Optional[UUID] = None, **kwargs: Any) -> Callable[..., Type[BaseNodeDisplay]]:
+        NodeDisplayType = TypeVar("NodeDisplayType", bound=BaseNodeDisplay)
+
+        def decorator(wrapped_node_display_class: Type[NodeDisplayType]) -> Type[NodeDisplayType]:
+            node_class = wrapped_node_display_class.infer_node_class()
+            if not issubclass(node_class, BaseAdornmentNode):
+                raise ValueError(f"Node {node_class.__name__} must be wrapped with a {BaseAdornmentNode.__name__}")
+
+            # `mypy` is wrong here, `cls` is indexable bc it's Generic
+            BaseAdornmentDisplay = cls[node_class]  # type: ignore[index]
+
+            def exec_body(ns: Dict):
+                for key, kwarg in kwargs.items():
+                    ns[key] = kwarg
+
+                ns["node_id"] = node_id or uuid4_from_hash(node_class.__qualname__)
+                ns["__wrapped_node_display__"] = wrapped_node_display_class
+
+            AdornmentDisplay = types.new_class(
+                re.sub(r"^Base", "", cls.__name__), bases=(BaseAdornmentDisplay,), exec_body=exec_body
+            )
+
+            setattr(wrapped_node_display_class, "__adorned_by__", AdornmentDisplay)
+
+            _recursively_replace_wrapped_node(
+                node_class,
+                wrapped_node_display_class,
+            )
+
+            return AdornmentDisplay
+
+        return decorator

vellum_ai-0.14.23/ee/vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -0,0 +1,70 @@
+from uuid import UUID
+from typing import Any, ClassVar, Generic, Optional, TypeVar
+
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.types.core import JsonObject
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.utils import to_kebab_case
+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.vellum import infer_vellum_variable_type
+
+_FinalOutputNodeType = TypeVar("_FinalOutputNodeType", bound=FinalOutputNode)
+
+
+class BaseFinalOutputNodeDisplay(BaseNodeVellumDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
+    output_id: ClassVar[Optional[UUID]] = None
+    output_name: ClassVar[Optional[str]] = None
+    node_input_id: ClassVar[Optional[UUID]] = None
+
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        node_input = create_node_input(
+            node_id,
+            "node_input",
+            # Get the pointer that the Terminal Node's output is referencing
+            node.Outputs.value.instance,
+            display_context,
+            self._get_node_input_id(),
+        )
+        inferred_type = infer_vellum_variable_type(node.Outputs.value)
+
+        return {
+            "id": str(node_id),
+            "type": "TERMINAL",
+            "data": {
+                "label": self.label,
+                "name": self._get_output_name(),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "output_id": str(self._get_output_id()),
+                "output_type": inferred_type,
+                "node_input_id": str(node_input.id),
+            },
+            "inputs": [node_input.dict()],
+            "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
+            "definition": self.get_definition().dict(),
+            "outputs": [
+                {
+                    "id": str(self._get_output_id()),
+                    "name": node.Outputs.value.name,
+                    "type": inferred_type,
+                    "value": self.serialize_value(display_context, node.Outputs.value.instance),
+                }
+            ],
+        }
+
+    def _get_output_id(self) -> UUID:
+        explicit_value = self._get_explicit_node_display_attr("output_id", UUID)
+        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|output_id")
+
+    def _get_output_name(self) -> str:
+        explicit_value = self._get_explicit_node_display_attr("output_name", str)
+        return explicit_value if explicit_value else to_kebab_case(self._node.__name__)
+
+    def _get_node_input_id(self) -> UUID:
+        explicit_value = self._get_explicit_node_display_attr("node_input_id", UUID)
+        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|node_input_id")

vellum_ai-0.14.23/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py

@@ -0,0 +1,110 @@
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_final_output_node.workflow import BasicFinalOutputNodeWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a Final Output Node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicFinalOutputNodeWorkflow
+    )
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+    assert input_variables == [
+        {
+            "id": "e39a7b63-de15-490a-ae9b-8112c767aea0",
+            "key": "input",
+            "type": "STRING",
+            "required": True,
+            "default": None,
+            "extensions": {"color": None},
+        }
+    ]
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert output_variables == [
+        {
+            "id": "a34cd21e-40e5-47f4-8fdb-910593f3e9e2",
+            "key": "value",
+            "type": "STRING",
+        }
+    ]
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert workflow_raw_data.keys() == {"edges", "nodes", "display_data", "definition"}
+    assert len(workflow_raw_data["edges"]) == 1
+    assert len(workflow_raw_data["nodes"]) == 2
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "631e2789-d60d-4088-9e3a-0ea93517075b",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "8b8d52a2-844f-44fe-a6c4-142fa70d391b"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": None,
+        "definition": None,
+    }
+
+    final_output_node = workflow_raw_data["nodes"][1]
+    assert final_output_node == {
+        "id": "620ec17b-e330-4212-b619-3c39dc63fb22",
+        "type": "TERMINAL",
+        "data": {
+            "label": "Basic Final Output Node",
+            "name": "basic-final-output-node",
+            "target_handle_id": "0173d3c6-11d1-44b7-b070-ca9ff5119046",
+            "output_id": "97349956-d228-4b51-a64b-1331f788373f",
+            "output_type": "STRING",
+            "node_input_id": "5322567a-f40c-400a-96b3-c3b054db543e",
+        },
+        "inputs": [
+            {
+                "id": "5322567a-f40c-400a-96b3-c3b054db543e",
+                "key": "node_input",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "e39a7b63-de15-490a-ae9b-8112c767aea0"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            }
+        ],
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": {
+            "name": "FinalOutputNode",
+            "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+        },
+        "definition": {
+            "name": "BasicFinalOutputNode",
+            "module": ["tests", "workflows", "basic_final_output_node", "workflow"],
+        },
+        "outputs": [
+            {
+                "id": "97349956-d228-4b51-a64b-1331f788373f",
+                "name": "value",
+                "type": "STRING",
+                "value": {"type": "WORKFLOW_INPUT", "input_variable_id": "e39a7b63-de15-490a-ae9b-8112c767aea0"},
+            }
+        ],
+    }