vellum-ai 0.10.6__tar.gz → 0.10.7__tar.gz

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/PKG-INFO

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

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/ee/vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -1,14 +1,16 @@
 from uuid import UUID
 from typing import Any, ClassVar, Generic, Optional, TypeVar
 
+from vellum.workflows.nodes.core.map_node.node import MapNode
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.core import JsonObject
 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.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
-from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
-from vellum.workflows.types.core import JsonObject
 
 _FinalOutputNodeType = TypeVar("_FinalOutputNodeType", bound=FinalOutputNode)
 

vellum_ai-0.10.7/ee/vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -0,0 +1,72 @@
+from uuid import UUID
+from typing import Collection, Dict, Generic, List, Optional, TypeVar, cast
+
+from vellum.workflows.nodes import MapNode
+from vellum.workflows.types.core import JsonObject
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+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.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+_MapNodeType = TypeVar("_MapNodeType", bound=MapNode)
+
+
+class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeType]):
+    def serialize(
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+    ) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        subworkflow = raise_if_descriptor(node.subworkflow)
+
+        items_node_input = create_node_input(
+            node_id=node_id,
+            input_name="items",
+            value=node.items,
+            display_context=display_context,
+            input_id=self.node_input_ids_by_name.get("items"),
+        )
+        node_inputs = [items_node_input]
+
+        subworkflow_display = get_workflow_display(
+            base_display_class=display_context.workflow_display_class,
+            workflow_class=subworkflow,
+        )
+        serialized_subworkflow = subworkflow_display.serialize()
+
+        renamed_input_variables = []
+        for input_variable in cast(List[Dict[str, str]], serialized_subworkflow["input_variables"]):
+            if input_variable["key"] == "all_items":
+                renamed_item = { **input_variable, "key": "items" }
+                renamed_input_variables.append(renamed_item)
+            else:
+                renamed_input_variables.append(input_variable)
+
+        # Note: This must match the items input ID for the map node's node input
+        items_workflow_input_id = next(input_variable["id"] for input_variable in renamed_input_variables if input_variable["key"] == "items")
+        item_workflow_input_id = next(input_variable["id"] for input_variable in renamed_input_variables if input_variable["key"] == "item")
+        index_workflow_input_id = next(input_variable["id"] for input_variable in renamed_input_variables if input_variable["key"] == "index")
+
+        return {
+            "id": str(node_id),
+            "type": "MAP",
+            "inputs": [node_input.dict() for node_input in node_inputs],
+            "data": {
+                "label": self.label,
+                "error_output_id": str(error_output_id) if error_output_id else None,
+                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "variant": "INLINE",
+                "workflow_raw_data": serialized_subworkflow["workflow_raw_data"],
+                "input_variables": cast(JsonObject, renamed_input_variables),
+                "output_variables": serialized_subworkflow["output_variables"],
+                "concurrency": raise_if_descriptor(node.concurrency),
+                "items_input_id": items_workflow_input_id,
+                "item_input_id": item_workflow_input_id,
+                "index_input_id": index_workflow_input_id,
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_conditional_node_serialization.py

@@ -13,30 +13,20 @@ from vellum.workflows.expressions.does_not_equal import DoesNotEqualExpression
 from vellum.workflows.expressions.ends_with import EndsWithExpression
 from vellum.workflows.expressions.equals import EqualsExpression
 from vellum.workflows.expressions.greater_than import GreaterThanExpression
-from vellum.workflows.expressions.greater_than_or_equal_to import (
-    GreaterThanOrEqualToExpression,
-)
+from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
 from vellum.workflows.expressions.in_ import InExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
 from vellum.workflows.expressions.less_than import LessThanExpression
-from vellum.workflows.expressions.less_than_or_equal_to import (
-    LessThanOrEqualToExpression,
-)
+from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.not_in import NotInExpression
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import (
-    BaseNodeVellumDisplay,
-)
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
-from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import (
-    get_workflow_display,
-)
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 from tests.workflows.basic_conditional_node.workflow import CategoryWorkflow
-from tests.workflows.basic_conditional_node.workflow_with_only_one_conditional_node import (
-    create_simple_workflow,
-)
+from tests.workflows.basic_conditional_node.workflow_with_only_one_conditional_node import create_simple_workflow
 
 
 def test_serialize_workflow():
@@ -965,7 +955,6 @@ def test_conditional_node_serialize_all_operators_with_lhs_and_rhs(
 
     # AND the conditional node should be what we expect
     conditional_node = workflow_raw_data["nodes"][1]
-    print(conditional_node)
     assert not DeepDiff(
         {
             "id": "a9143814-6bb0-4cb3-a817-4fc076417121",

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_map_node_serialization.py

@@ -228,15 +228,15 @@ def test_serialize_workflow():
                     },
                 },
                 "input_variables": [
-                    {"id": "0fe9dff5-7595-4ff3-a420-416f3fc6f809", "key": "item", "type": "JSON"},
-                    {"id": "27dfe8ba-8be7-4de9-a930-2ec3e375b149", "key": "index", "type": "NUMBER"},
-                    {"id": "4c0a109f-599e-4d04-a396-a51474fc2996", "key": "items", "type": "JSON"},
+                    {"id": "b29bb546-9bc8-4136-857d-8c7a464ba9d4", "key": "item", "type": "JSON", "required": True, "default": None, "extensions": {"color": None}},
+                    {"id": "17e7ca49-668f-450d-a792-e1f97d13db67", "key": "index", "type": "NUMBER", "required": True, "default": None, "extensions": {"color": None}},
+                    {"id": "d6fc6c7a-235f-4b98-86f3-e258d1198f93", "key": "items", "type": "JSON", "required": True, "default": None, "extensions": {"color": None}},
                 ],
-                "output_variables": [{"id": "56b34d4a-d3a6-4bdb-80a4-dbf644791274", "key": "count", "type": "NUMBER"}],
+                "output_variables": [{"id": "2a957315-fae0-4366-8a35-f0b315c5eade", "key": "count", "type": "NUMBER"}],
                 "concurrency": None,
-                "items_input_id": "4c0a109f-599e-4d04-a396-a51474fc2996",
-                "item_input_id": "0fe9dff5-7595-4ff3-a420-416f3fc6f809",
-                "index_input_id": "27dfe8ba-8be7-4de9-a930-2ec3e375b149",
+                "items_input_id": "d6fc6c7a-235f-4b98-86f3-e258d1198f93",
+                "item_input_id": "b29bb546-9bc8-4136-857d-8c7a464ba9d4",
+                "index_input_id": "17e7ca49-668f-450d-a792-e1f97d13db67",
             },
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "definition": {
@@ -288,7 +288,7 @@ def test_serialize_workflow():
                                 "type": "NODE_OUTPUT",
                                 "data": {
                                     "node_id": "bf83099a-40df-4445-b90d-1f6f1067ebe3",
-                                    "output_id": "56b34d4a-d3a6-4bdb-80a4-dbf644791274",
+                                    "output_id": "2a957315-fae0-4366-8a35-f0b315c5eade",
                                 },
                             }
                         ],
@@ -323,6 +323,9 @@ def test_serialize_workflow():
             },
         },
         workflow_raw_data["nodes"][2],
+        # TODO: Fix output ID not referencing map node workflow output
+        # https://app.shortcut.com/vellum/story/5667/fix-output-display-reference-on-map-nodes
+        exclude_regex_paths=r"root\['inputs'\]\[0\]\['value'\]\['rules'\]\[0\]\['data'\]\['output_id'\]",
     )
 
     # AND each edge should be serialized correctly

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/ee/vellum_ee/workflows/display/utils/vellum.py

@@ -4,7 +4,9 @@ import typing
 from typing import Any, List, Union, cast
 
 from vellum import ChatMessage, SearchResult, SearchResultRequest, VellumVariableType
+from vellum.client.types.array_vellum_value import ArrayVellumValue
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.nodes.core.map_node.node import MapNodeItemType
 from vellum.workflows.references import OutputReference, WorkflowInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.node import NodeReference
@@ -45,9 +47,8 @@ def infer_vellum_variable_type(value: Any) -> VellumVariableType:
                 raise ValueError(
                     f"Expected NodeReference {descriptor.name} to have an instance pointing to a descriptor"
                 )
-
             descriptor = descriptor.instance
-
+        
         inferred_type = primitive_type_to_vellum_variable_type(descriptor)
     else:
         vellum_variable_value = primitive_to_vellum_value(value)

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/pyproject.toml

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

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/src/vellum/__init__.py

@@ -186,6 +186,7 @@ from .types import (
     MetadataFilterRuleRequest,
     MetadataFiltersRequest,
     MetricDefinitionExecution,
+    MetricDefinitionHistoryItem,
     MetricDefinitionInput,
     MetricNodeResult,
     MlModelRead,
@@ -708,6 +709,7 @@ __all__ = [
     "MetadataFilterRuleRequest",
     "MetadataFiltersRequest",
     "MetricDefinitionExecution",
+    "MetricDefinitionHistoryItem",
     "MetricDefinitionInput",
     "MetricNodeResult",
     "MlModelRead",

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/src/vellum/client/README.md

@@ -91,82 +91,37 @@ The SDK supports streaming responses, as well, the response will be a generator
 
 ```python
 from vellum import (
-    AdHocExpandMeta,
-    EphemeralPromptCacheConfig,
-    FunctionDefinition,
     JinjaPromptBlock,
     PromptParameters,
     PromptRequestStringInput,
-    PromptSettings,
-    StringVellumValue,
     Vellum,
     VellumVariable,
-    VellumVariableExtensions,
 )
 
 client = Vellum(
     api_key="YOUR_API_KEY",
 )
 response = client.ad_hoc.adhoc_execute_prompt_stream(
-    ml_model="string",
+    ml_model="ml_model",
     input_values=[
         PromptRequestStringInput(
-            key="string",
-            value="string",
+            key="key",
+            value="value",
         )
     ],
     input_variables=[
         VellumVariable(
-            id="string",
-            key="string",
+            id="id",
+            key="key",
             type="STRING",
-            required=True,
-            default=StringVellumValue(
-                value="string",
-            ),
-            extensions=VellumVariableExtensions(
-                color={"key": "value"},
-            ),
         )
     ],
-    parameters=PromptParameters(
-        stop=["string"],
-        temperature=1.1,
-        max_tokens=1,
-        top_p=1.1,
-        top_k=1,
-        frequency_penalty=1.1,
-        presence_penalty=1.1,
-        logit_bias={"string": {"key": "value"}},
-        custom_parameters={"string": {"key": "value"}},
-    ),
-    settings=PromptSettings(
-        timeout=1.1,
-    ),
+    parameters=PromptParameters(),
     blocks=[
         JinjaPromptBlock(
-            state="ENABLED",
-            cache_config=EphemeralPromptCacheConfig(),
-            template="string",
+            template="template",
         )
     ],
-    functions=[
-        FunctionDefinition(
-            state="ENABLED",
-            cache_config=EphemeralPromptCacheConfig(),
-            name="string",
-            description="string",
-            parameters={"string": {"key": "value"}},
-            forced=True,
-            strict=True,
-        )
-    ],
-    expand_meta=AdHocExpandMeta(
-        cost=True,
-        model_name=True,
-        usage=True,
-        finish_reason=True,
-    ),
 )
 for chunk in response:
     yield chunk

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/src/vellum/client/__init__.py

@@ -447,12 +447,7 @@ class Vellum:
 
         Examples
         --------
-        from vellum import (
-            PromptDeploymentExpandMetaRequest,
-            RawPromptExecutionOverridesRequest,
-            StringInputRequest,
-            Vellum,
-        )
+        from vellum import StringInputRequest, Vellum
 
         client = Vellum(
             api_key="YOUR_API_KEY",
@@ -460,30 +455,10 @@ class Vellum:
         response = client.execute_prompt_stream(
             inputs=[
                 StringInputRequest(
-                    name="string",
-                    value="string",
+                    name="name",
+                    value="value",
                 )
             ],
-            prompt_deployment_id="string",
-            prompt_deployment_name="string",
-            release_tag="string",
-            external_id="string",
-            expand_meta=PromptDeploymentExpandMetaRequest(
-                model_name=True,
-                usage=True,
-                cost=True,
-                finish_reason=True,
-                latency=True,
-                deployment_release_tag=True,
-                prompt_version_id=True,
-            ),
-            raw_overrides=RawPromptExecutionOverridesRequest(
-                body={"string": {"key": "value"}},
-                headers={"string": {"key": "value"}},
-                url="string",
-            ),
-            expand_raw=["string"],
-            metadata={"string": {"key": "value"}},
         )
         for chunk in response:
             yield chunk
@@ -752,11 +727,7 @@ class Vellum:
 
         Examples
         --------
-        from vellum import (
-            Vellum,
-            WorkflowExpandMetaRequest,
-            WorkflowRequestStringInputRequest,
-        )
+        from vellum import Vellum, WorkflowRequestStringInputRequest
 
         client = Vellum(
             api_key="YOUR_API_KEY",
@@ -764,19 +735,10 @@ class Vellum:
         response = client.execute_workflow_stream(
             inputs=[
                 WorkflowRequestStringInputRequest(
-                    name="string",
-                    value="string",
+                    name="name",
+                    value="value",
                 )
             ],
-            expand_meta=WorkflowExpandMetaRequest(
-                usage=True,
-            ),
-            workflow_deployment_id="string",
-            workflow_deployment_name="string",
-            release_tag="string",
-            external_id="string",
-            event_types=["NODE"],
-            metadata={"string": {"key": "value"}},
         )
         for chunk in response:
             yield chunk
@@ -1016,39 +978,17 @@ class Vellum:
 
         Examples
         --------
-        from vellum import (
-            ChatMessageRequest,
-            GenerateOptionsRequest,
-            GenerateRequest,
-            StringChatMessageContentRequest,
-            Vellum,
-        )
+        from vellum import GenerateRequest, Vellum
 
         client = Vellum(
             api_key="YOUR_API_KEY",
         )
         response = client.generate_stream(
-            deployment_id="string",
-            deployment_name="string",
             requests=[
                 GenerateRequest(
-                    input_values={"string": {"key": "value"}},
-                    chat_history=[
-                        ChatMessageRequest(
-                            text="string",
-                            role="SYSTEM",
-                            content=StringChatMessageContentRequest(
-                                value="string",
-                            ),
-                            source="string",
-                        )
-                    ],
-                    external_ids=["string"],
+                    input_values={"key": "value"},
                 )
             ],
-            options=GenerateOptionsRequest(
-                logprobs="ALL",
-            ),
         )
         for chunk in response:
             yield chunk
@@ -1785,12 +1725,7 @@ class AsyncVellum:
         --------
         import asyncio
 
-        from vellum import (
-            AsyncVellum,
-            PromptDeploymentExpandMetaRequest,
-            RawPromptExecutionOverridesRequest,
-            StringInputRequest,
-        )
+        from vellum import AsyncVellum, StringInputRequest
 
         client = AsyncVellum(
             api_key="YOUR_API_KEY",
@@ -1801,30 +1736,10 @@ class AsyncVellum:
             response = await client.execute_prompt_stream(
                 inputs=[
                     StringInputRequest(
-                        name="string",
-                        value="string",
+                        name="name",
+                        value="value",
                     )
                 ],
-                prompt_deployment_id="string",
-                prompt_deployment_name="string",
-                release_tag="string",
-                external_id="string",
-                expand_meta=PromptDeploymentExpandMetaRequest(
-                    model_name=True,
-                    usage=True,
-                    cost=True,
-                    finish_reason=True,
-                    latency=True,
-                    deployment_release_tag=True,
-                    prompt_version_id=True,
-                ),
-                raw_overrides=RawPromptExecutionOverridesRequest(
-                    body={"string": {"key": "value"}},
-                    headers={"string": {"key": "value"}},
-                    url="string",
-                ),
-                expand_raw=["string"],
-                metadata={"string": {"key": "value"}},
             )
             async for chunk in response:
                 yield chunk
@@ -2106,11 +2021,7 @@ class AsyncVellum:
         --------
         import asyncio
 
-        from vellum import (
-            AsyncVellum,
-            WorkflowExpandMetaRequest,
-            WorkflowRequestStringInputRequest,
-        )
+        from vellum import AsyncVellum, WorkflowRequestStringInputRequest
 
         client = AsyncVellum(
             api_key="YOUR_API_KEY",
@@ -2121,19 +2032,10 @@ class AsyncVellum:
             response = await client.execute_workflow_stream(
                 inputs=[
                     WorkflowRequestStringInputRequest(
-                        name="string",
-                        value="string",
+                        name="name",
+                        value="value",
                     )
                 ],
-                expand_meta=WorkflowExpandMetaRequest(
-                    usage=True,
-                ),
-                workflow_deployment_id="string",
-                workflow_deployment_name="string",
-                release_tag="string",
-                external_id="string",
-                event_types=["NODE"],
-                metadata={"string": {"key": "value"}},
             )
             async for chunk in response:
                 yield chunk
@@ -2386,13 +2288,7 @@ class AsyncVellum:
         --------
         import asyncio
 
-        from vellum import (
-            AsyncVellum,
-            ChatMessageRequest,
-            GenerateOptionsRequest,
-            GenerateRequest,
-            StringChatMessageContentRequest,
-        )
+        from vellum import AsyncVellum, GenerateRequest
 
         client = AsyncVellum(
             api_key="YOUR_API_KEY",
@@ -2401,27 +2297,11 @@ class AsyncVellum:
 
         async def main() -> None:
             response = await client.generate_stream(
-                deployment_id="string",
-                deployment_name="string",
                 requests=[
                     GenerateRequest(
-                        input_values={"string": {"key": "value"}},
-                        chat_history=[
-                            ChatMessageRequest(
-                                text="string",
-                                role="SYSTEM",
-                                content=StringChatMessageContentRequest(
-                                    value="string",
-                                ),
-                                source="string",
-                            )
-                        ],
-                        external_ids=["string"],
+                        input_values={"key": "value"},
                     )
                 ],
-                options=GenerateOptionsRequest(
-                    logprobs="ALL",
-                ),
             )
             async for chunk in response:
                 yield chunk

{vellum_ai-0.10.6 → vellum_ai-0.10.7}/src/vellum/client/core/client_wrapper.py

@@ -17,7 +17,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.10.6",
+            "X-Fern-SDK-Version": "0.10.7",
         }
         headers["X_API_KEY"] = self.api_key
         return headers