vellum-ai 0.8.7__tar.gz → 0.8.10__tar.gz

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.8.7
+Version: 0.8.10
 Summary: 
 License: MIT
 Requires-Python: >=3.8,<4.0

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/pyproject.toml

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

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/__init__.py

@@ -209,6 +209,7 @@ from .types import (
     PdfSearchResultMetaSource,
     PdfSearchResultMetaSourceRequest,
     PlainTextPromptBlockRequest,
+    Price,
     ProcessingFailureReasonEnum,
     ProcessingStateEnum,
     PromptBlockRequest,
@@ -333,6 +334,7 @@ from .types import (
     TestSuiteRunExternalExecConfigDataRequest,
     TestSuiteRunExternalExecConfigRequest,
     TestSuiteRunMetricErrorOutput,
+    TestSuiteRunMetricJsonOutput,
     TestSuiteRunMetricNumberOutput,
     TestSuiteRunMetricOutput,
     TestSuiteRunMetricStringOutput,
@@ -362,6 +364,7 @@ from .types import (
     TokenOverlappingWindowChunkerConfigRequest,
     TokenOverlappingWindowChunking,
     TokenOverlappingWindowChunkingRequest,
+    UnitEnum,
     UploadDocumentResponse,
     UpsertTestSuiteTestCaseRequest,
     VariablePromptBlockRequest,
@@ -651,6 +654,7 @@ __all__ = [
     "PdfSearchResultMetaSource",
     "PdfSearchResultMetaSourceRequest",
     "PlainTextPromptBlockRequest",
+    "Price",
     "ProcessingFailureReasonEnum",
     "ProcessingStateEnum",
     "PromptBlockRequest",
@@ -775,6 +779,7 @@ __all__ = [
     "TestSuiteRunExternalExecConfigDataRequest",
     "TestSuiteRunExternalExecConfigRequest",
     "TestSuiteRunMetricErrorOutput",
+    "TestSuiteRunMetricJsonOutput",
     "TestSuiteRunMetricNumberOutput",
     "TestSuiteRunMetricOutput",
     "TestSuiteRunMetricStringOutput",
@@ -804,6 +809,7 @@ __all__ = [
     "TokenOverlappingWindowChunkerConfigRequest",
     "TokenOverlappingWindowChunking",
     "TokenOverlappingWindowChunkingRequest",
+    "UnitEnum",
     "UploadDocumentResponse",
     "UpsertTestSuiteTestCaseRequest",
     "VariablePromptBlockRequest",

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/client.py

@@ -344,6 +344,7 @@ class Vellum:
             expand_meta=PromptDeploymentExpandMetaRequest(
                 model_name=True,
                 usage=True,
+                cost=True,
                 finish_reason=True,
                 latency=True,
                 deployment_release_tag=True,
@@ -891,7 +892,9 @@ class Vellum:
                         ChatMessageRequest(
                             text="string",
                             role="SYSTEM",
-                            content=StringChatMessageContentRequest(),
+                            content=StringChatMessageContentRequest(
+                                value="string",
+                            ),
                             source="string",
                         )
                     ],
@@ -1535,6 +1538,7 @@ class AsyncVellum:
                 expand_meta=PromptDeploymentExpandMetaRequest(
                     model_name=True,
                     usage=True,
+                    cost=True,
                     finish_reason=True,
                     latency=True,
                     deployment_release_tag=True,
@@ -2114,7 +2118,9 @@ class AsyncVellum:
                             ChatMessageRequest(
                                 text="string",
                                 role="SYSTEM",
-                                content=StringChatMessageContentRequest(),
+                                content=StringChatMessageContentRequest(
+                                    value="string",
+                                ),
                                 source="string",
                             )
                         ],

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/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.8.7",
+            "X-Fern-SDK-Version": "0.8.10",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/core/pydantic_utilities.py

@@ -80,6 +80,8 @@ class UniversalBaseModel(pydantic.BaseModel):
         smart_union = True
         allow_population_by_field_name = True
         json_encoders = {dt.datetime: serialize_datetime}
+        # Allow fields begining with `model_` to be used in the model
+        protected_namespaces = ()
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {
@@ -97,30 +99,64 @@ class UniversalBaseModel(pydantic.BaseModel):
         Override the default dict method to `exclude_unset` by default. This function patches
         `exclude_unset` to work include fields within non-None default values.
         """
-        _fields_set = self.__fields_set__
-
-        fields = _get_model_fields(self.__class__)
-        for name, field in fields.items():
-            if name not in _fields_set:
-                default = _get_field_default(field)
-
-                # If the default values are non-null act like they've been set
-                # This effectively allows exclude_unset to work like exclude_none where
-                # the latter passes through intentionally set none values.
-                if default != None:
-                    _fields_set.add(name)
-
-        kwargs_with_defaults_exclude_unset: typing.Any = {
-            "by_alias": True,
-            "exclude_unset": True,
-            "include": _fields_set,
-            **kwargs,
-        }
-
+        # Note: the logic here is multi-plexed given the levers exposed in Pydantic V1 vs V2
+        # Pydantic V1's .dict can be extremely slow, so we do not want to call it twice.
+        #
+        # We'd ideally do the same for Pydantic V2, but it shells out to a library to serialize models
+        # that we have less control over, and this is less intrusive than custom serializers for now.
         if IS_PYDANTIC_V2:
-            return super().model_dump(**kwargs_with_defaults_exclude_unset)  # type: ignore # Pydantic v2
+            kwargs_with_defaults_exclude_unset: typing.Any = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_unset": True,
+                "exclude_none": False,
+            }
+            kwargs_with_defaults_exclude_none: typing.Any = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_none": True,
+                "exclude_unset": False,
+            }
+            return deep_union_pydantic_dicts(
+                super().model_dump(**kwargs_with_defaults_exclude_unset),  # type: ignore # Pydantic v2
+                super().model_dump(**kwargs_with_defaults_exclude_none),  # type: ignore # Pydantic v2
+            )
+
         else:
-            return super().dict(**kwargs_with_defaults_exclude_unset)
+            _fields_set = self.__fields_set__
+
+            fields = _get_model_fields(self.__class__)
+            for name, field in fields.items():
+                if name not in _fields_set:
+                    default = _get_field_default(field)
+
+                    # If the default values are non-null act like they've been set
+                    # This effectively allows exclude_unset to work like exclude_none where
+                    # the latter passes through intentionally set none values.
+                    if default != None:
+                        _fields_set.add(name)
+
+            kwargs_with_defaults_exclude_unset_include_fields: typing.Any = {
+                "by_alias": True,
+                "exclude_unset": True,
+                "include": _fields_set,
+                **kwargs,
+            }
+
+            return super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
+
+
+def deep_union_pydantic_dicts(
+    source: typing.Dict[str, typing.Any], destination: typing.Dict[str, typing.Any]
+) -> typing.Dict[str, typing.Any]:
+    for key, value in source.items():
+        if isinstance(value, dict):
+            node = destination.setdefault(key, {})
+            deep_union_pydantic_dicts(value, node)
+        else:
+            destination[key] = value
+
+    return destination
 
 
 if IS_PYDANTIC_V2:

vellum_ai-0.8.10/src/vellum/core/serialization.py

@@ -0,0 +1,254 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import collections
+import inspect
+import typing
+
+import typing_extensions
+
+import pydantic
+
+
+class FieldMetadata:
+    """
+    Metadata class used to annotate fields to provide additional information.
+
+    Example:
+    class MyDict(TypedDict):
+        field: typing.Annotated[str, FieldMetadata(alias="field_name")]
+
+    Will serialize: `{"field": "value"}`
+    To: `{"field_name": "value"}`
+    """
+
+    alias: str
+
+    def __init__(self, *, alias: str) -> None:
+        self.alias = alias
+
+
+def convert_and_respect_annotation_metadata(
+    *,
+    object_: typing.Any,
+    annotation: typing.Any,
+    inner_type: typing.Optional[typing.Any] = None,
+    direction: typing.Literal["read", "write"],
+) -> typing.Any:
+    """
+    Respect the metadata annotations on a field, such as aliasing. This function effectively
+    manipulates the dict-form of an object to respect the metadata annotations. This is primarily used for
+    TypedDicts, which cannot support aliasing out of the box, and can be extended for additional
+    utilities, such as defaults.
+
+    Parameters
+    ----------
+    object_ : typing.Any
+
+    annotation : type
+        The type we're looking to apply typing annotations from
+
+    inner_type : typing.Optional[type]
+
+    Returns
+    -------
+    typing.Any
+    """
+
+    if object_ is None:
+        return None
+    if inner_type is None:
+        inner_type = annotation
+
+    clean_type = _remove_annotations(inner_type)
+    # Pydantic models
+    if (
+        inspect.isclass(clean_type)
+        and issubclass(clean_type, pydantic.BaseModel)
+        and isinstance(object_, typing.Mapping)
+    ):
+        return _convert_mapping(object_, clean_type, direction)
+    # TypedDicts
+    if typing_extensions.is_typeddict(clean_type) and isinstance(object_, typing.Mapping):
+        return _convert_mapping(object_, clean_type, direction)
+
+    # If you're iterating on a string, do not bother to coerce it to a sequence.
+    if not isinstance(object_, str):
+        if (
+            typing_extensions.get_origin(clean_type) == typing.Set
+            or typing_extensions.get_origin(clean_type) == set
+            or clean_type == typing.Set
+        ) and isinstance(object_, typing.Set):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return {
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            }
+        elif (
+            (
+                typing_extensions.get_origin(clean_type) == typing.List
+                or typing_extensions.get_origin(clean_type) == list
+                or clean_type == typing.List
+            )
+            and isinstance(object_, typing.List)
+        ) or (
+            (
+                typing_extensions.get_origin(clean_type) == typing.Sequence
+                or typing_extensions.get_origin(clean_type) == collections.abc.Sequence
+                or clean_type == typing.Sequence
+            )
+            and isinstance(object_, typing.Sequence)
+        ):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return [
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            ]
+
+    if typing_extensions.get_origin(clean_type) == typing.Union:
+        # We should be able to ~relatively~ safely try to convert keys against all
+        # member types in the union, the edge case here is if one member aliases a field
+        # of the same name to a different name from another member
+        # Or if another member aliases a field of the same name that another member does not.
+        for member in typing_extensions.get_args(clean_type):
+            object_ = convert_and_respect_annotation_metadata(
+                object_=object_,
+                annotation=annotation,
+                inner_type=member,
+                direction=direction,
+            )
+        return object_
+
+    annotated_type = _get_annotation(annotation)
+    if annotated_type is None:
+        return object_
+
+    # If the object is not a TypedDict, a Union, or other container (list, set, sequence, etc.)
+    # Then we can safely call it on the recursive conversion.
+    return object_
+
+
+def _convert_mapping(
+    object_: typing.Mapping[str, object],
+    expected_type: typing.Any,
+    direction: typing.Literal["read", "write"],
+) -> typing.Mapping[str, object]:
+    converted_object: typing.Dict[str, object] = {}
+    annotations = typing_extensions.get_type_hints(expected_type, include_extras=True)
+    aliases_to_field_names = _get_alias_to_field_name(annotations)
+    for key, value in object_.items():
+        if direction == "read" and key in aliases_to_field_names:
+            dealiased_key = aliases_to_field_names.get(key)
+            if dealiased_key is not None:
+                type_ = annotations.get(dealiased_key)
+        else:
+            type_ = annotations.get(key)
+        # Note you can't get the annotation by the field name if you're in read mode, so you must check the aliases map
+        #
+        # So this is effectively saying if we're in write mode, and we don't have a type, or if we're in read mode and we don't have an alias
+        # then we can just pass the value through as is
+        if type_ is None:
+            converted_object[key] = value
+        elif direction == "read" and key not in aliases_to_field_names:
+            converted_object[key] = convert_and_respect_annotation_metadata(
+                object_=value, annotation=type_, direction=direction
+            )
+        else:
+            converted_object[_alias_key(key, type_, direction, aliases_to_field_names)] = (
+                convert_and_respect_annotation_metadata(object_=value, annotation=type_, direction=direction)
+            )
+    return converted_object
+
+
+def _get_annotation(type_: typing.Any) -> typing.Optional[typing.Any]:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return None
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        type_ = typing_extensions.get_args(type_)[0]
+        maybe_annotated_type = typing_extensions.get_origin(type_)
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return type_
+
+    return None
+
+
+def _remove_annotations(type_: typing.Any) -> typing.Any:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return type_
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    return type_
+
+
+def get_alias_to_field_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_alias_to_field_name(annotations)
+
+
+def get_field_to_alias_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_field_to_alias_name(annotations)
+
+
+def _get_alias_to_field_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[maybe_alias] = field
+    return aliases
+
+
+def _get_field_to_alias_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[field] = maybe_alias
+    return aliases
+
+
+def _get_alias_from_type(type_: typing.Any) -> typing.Optional[str]:
+    maybe_annotated_type = _get_annotation(type_)
+
+    if maybe_annotated_type is not None:
+        # The actual annotations are 1 onward, the first is the annotated type
+        annotations = typing_extensions.get_args(maybe_annotated_type)[1:]
+
+        for annotation in annotations:
+            if isinstance(annotation, FieldMetadata) and annotation.alias is not None:
+                return annotation.alias
+    return None
+
+
+def _alias_key(
+    key: str,
+    type_: typing.Any,
+    direction: typing.Literal["read", "write"],
+    aliases_to_field_names: typing.Dict[str, str],
+) -> str:
+    if direction == "read":
+        return aliases_to_field_names.get(key, key)
+    return _get_alias_from_type(type_=type_) or key

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/resources/ad_hoc/client.py

@@ -112,7 +112,9 @@ class AdHocClient:
                     ),
                     id="string",
                     state="ENABLED",
-                    cache_config=EphemeralPromptCacheConfigRequest(),
+                    cache_config=EphemeralPromptCacheConfigRequest(
+                        type={"key": "value"},
+                    ),
                 )
             ],
             expand_meta=AdHocExpandMetaRequest(
@@ -288,7 +290,9 @@ class AsyncAdHocClient:
                         ),
                         id="string",
                         state="ENABLED",
-                        cache_config=EphemeralPromptCacheConfigRequest(),
+                        cache_config=EphemeralPromptCacheConfigRequest(
+                            type={"key": "value"},
+                        ),
                     )
                 ],
                 expand_meta=AdHocExpandMetaRequest(

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/resources/test_suites/client.py

@@ -229,8 +229,18 @@ class TestSuitesClient:
                     id="string",
                     data=CreateTestSuiteTestCaseRequest(
                         label="string",
-                        input_values=[NamedTestCaseStringVariableValueRequest()],
-                        evaluation_values=[NamedTestCaseStringVariableValueRequest()],
+                        input_values=[
+                            NamedTestCaseStringVariableValueRequest(
+                                value="string",
+                                name="string",
+                            )
+                        ],
+                        evaluation_values=[
+                            NamedTestCaseStringVariableValueRequest(
+                                value="string",
+                                name="string",
+                            )
+                        ],
                         external_id="string",
                     ),
                 )
@@ -548,9 +558,17 @@ class AsyncTestSuitesClient:
                         id="string",
                         data=CreateTestSuiteTestCaseRequest(
                             label="string",
-                            input_values=[NamedTestCaseStringVariableValueRequest()],
+                            input_values=[
+                                NamedTestCaseStringVariableValueRequest(
+                                    value="string",
+                                    name="string",
+                                )
+                            ],
                             evaluation_values=[
-                                NamedTestCaseStringVariableValueRequest()
+                                NamedTestCaseStringVariableValueRequest(
+                                    value="string",
+                                    name="string",
+                                )
                             ],
                             external_id="string",
                         ),

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/types/__init__.py

@@ -216,6 +216,7 @@ from .paginated_test_suite_test_case_list import PaginatedTestSuiteTestCaseList
 from .pdf_search_result_meta_source import PdfSearchResultMetaSource
 from .pdf_search_result_meta_source_request import PdfSearchResultMetaSourceRequest
 from .plain_text_prompt_block_request import PlainTextPromptBlockRequest
+from .price import Price
 from .processing_failure_reason_enum import ProcessingFailureReasonEnum
 from .processing_state_enum import ProcessingStateEnum
 from .prompt_block_request import PromptBlockRequest
@@ -342,6 +343,7 @@ from .test_suite_run_external_exec_config_data import TestSuiteRunExternalExecCo
 from .test_suite_run_external_exec_config_data_request import TestSuiteRunExternalExecConfigDataRequest
 from .test_suite_run_external_exec_config_request import TestSuiteRunExternalExecConfigRequest
 from .test_suite_run_metric_error_output import TestSuiteRunMetricErrorOutput
+from .test_suite_run_metric_json_output import TestSuiteRunMetricJsonOutput
 from .test_suite_run_metric_number_output import TestSuiteRunMetricNumberOutput
 from .test_suite_run_metric_output import TestSuiteRunMetricOutput
 from .test_suite_run_metric_string_output import TestSuiteRunMetricStringOutput
@@ -373,6 +375,7 @@ from .token_overlapping_window_chunker_config import TokenOverlappingWindowChunk
 from .token_overlapping_window_chunker_config_request import TokenOverlappingWindowChunkerConfigRequest
 from .token_overlapping_window_chunking import TokenOverlappingWindowChunking
 from .token_overlapping_window_chunking_request import TokenOverlappingWindowChunkingRequest
+from .unit_enum import UnitEnum
 from .upload_document_response import UploadDocumentResponse
 from .upsert_test_suite_test_case_request import UpsertTestSuiteTestCaseRequest
 from .variable_prompt_block_request import VariablePromptBlockRequest
@@ -635,6 +638,7 @@ __all__ = [
     "PdfSearchResultMetaSource",
     "PdfSearchResultMetaSourceRequest",
     "PlainTextPromptBlockRequest",
+    "Price",
     "ProcessingFailureReasonEnum",
     "ProcessingStateEnum",
     "PromptBlockRequest",
@@ -759,6 +763,7 @@ __all__ = [
     "TestSuiteRunExternalExecConfigDataRequest",
     "TestSuiteRunExternalExecConfigRequest",
     "TestSuiteRunMetricErrorOutput",
+    "TestSuiteRunMetricJsonOutput",
     "TestSuiteRunMetricNumberOutput",
     "TestSuiteRunMetricOutput",
     "TestSuiteRunMetricStringOutput",
@@ -788,6 +793,7 @@ __all__ = [
     "TokenOverlappingWindowChunkerConfigRequest",
     "TokenOverlappingWindowChunking",
     "TokenOverlappingWindowChunkingRequest",
+    "UnitEnum",
     "UploadDocumentResponse",
     "UpsertTestSuiteTestCaseRequest",
     "VariablePromptBlockRequest",

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/types/ad_hoc_expand_meta_request.py

@@ -7,7 +7,11 @@ from ..core.pydantic_utilities import IS_PYDANTIC_V2
 
 
 class AdHocExpandMetaRequest(UniversalBaseModel):
-    cost: typing.Optional[bool] = None
+    cost: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    If enabled, the response will include model host cost tracking. This may increase latency for some model hosts.
+    """
+
     model_name: typing.Optional[bool] = pydantic.Field(default=None)
     """
     If enabled, the response will include the model identifier representing the ML Model invoked by the Prompt.

vellum_ai-0.8.10/src/vellum/types/price.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+from .unit_enum import UnitEnum
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class Price(UniversalBaseModel):
+    value: float
+    unit: UnitEnum = "USD"
+
+    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-0.8.7 → vellum_ai-0.8.10}/src/vellum/types/prompt_deployment_expand_meta_request.py

@@ -17,6 +17,11 @@ class PromptDeploymentExpandMetaRequest(UniversalBaseModel):
     If enabled, the response will include model host usage tracking. This may increase latency for some model hosts.
     """
 
+    cost: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    If enabled, the response will include model host cost tracking. This may increase latency for some model hosts.
+    """
+
     finish_reason: typing.Optional[bool] = pydantic.Field(default=None)
     """
     If enabled, the response will include the reason provided by the model for why the execution finished.

{vellum_ai-0.8.7 → vellum_ai-0.8.10}/src/vellum/types/prompt_execution_meta.py

@@ -4,6 +4,7 @@ from ..core.pydantic_utilities import UniversalBaseModel
 import typing
 from .finish_reason_enum import FinishReasonEnum
 from .ml_model_usage import MlModelUsage
+from .price import Price
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -19,6 +20,7 @@ class PromptExecutionMeta(UniversalBaseModel):
     prompt_version_id: typing.Optional[str] = None
     finish_reason: typing.Optional[FinishReasonEnum] = None
     usage: typing.Optional[MlModelUsage] = None
+    cost: typing.Optional[Price] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum_ai-0.8.10/src/vellum/types/test_suite_run_metric_json_output.py

@@ -0,0 +1,25 @@
+# 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 TestSuiteRunMetricJsonOutput(UniversalBaseModel):
+    """
+    Output for a test suite run metric that is of type NUMBER
+    """
+
+    value: typing.Optional[typing.Any] = None
+    type: typing.Literal["JSON"] = "JSON"
+    name: str
+
+    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