vellum-ai 0.3.14 → 0.3.16

package/dist/serialization/types/ModelVersionRead.js

@@ -25,25 +25,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelVersionRead = void 0;
 const core = __importStar(require("../../core"));
+const ProviderEnum_1 = require("./ProviderEnum");
+const ModelVersionBuildConfig_1 = require("./ModelVersionBuildConfig");
+const ModelVersionExecConfig_1 = require("./ModelVersionExecConfig");
+const ModelVersionReadStatusEnum_1 = require("./ModelVersionReadStatusEnum");
 exports.ModelVersionRead = core.serialization.object({
     id: core.serialization.string(),
     created: core.serialization.date(),
     label: core.serialization.string(),
-    provider: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ProviderEnum; })),
+    provider: ProviderEnum_1.ProviderEnum,
     externalId: core.serialization.property("external_id", core.serialization.string()),
-    buildConfig: core.serialization.property("build_config", core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ModelVersionBuildConfig; }))),
-    execConfig: core.serialization.property("exec_config", core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ModelVersionExecConfig; }))),
-    status: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ModelVersionReadStatusEnum; })).optional(),
+    buildConfig: core.serialization.property("build_config", ModelVersionBuildConfig_1.ModelVersionBuildConfig),
+    execConfig: core.serialization.property("exec_config", ModelVersionExecConfig_1.ModelVersionExecConfig),
+    status: ModelVersionReadStatusEnum_1.ModelVersionReadStatusEnum.optional(),
 });

package/dist/serialization/types/NamedTestCaseChatHistoryVariableValueRequest.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessageRequest } from "./ChatMessageRequest";
 export declare const NamedTestCaseChatHistoryVariableValueRequest: core.serialization.ObjectSchema<serializers.NamedTestCaseChatHistoryVariableValueRequest.Raw, Vellum.NamedTestCaseChatHistoryVariableValueRequest>;
 export declare namespace NamedTestCaseChatHistoryVariableValueRequest {
     interface Raw {
         name: string;
-        value?: serializers.ChatMessageRequest.Raw[] | null;
+        value?: ChatMessageRequest.Raw[] | null;
     }
 }

package/dist/serialization/types/NamedTestCaseChatHistoryVariableValueRequest.js

@@ -25,21 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NamedTestCaseChatHistoryVariableValueRequest = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessageRequest_1 = require("./ChatMessageRequest");
 exports.NamedTestCaseChatHistoryVariableValueRequest = core.serialization.object({
     name: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessageRequest; })))
-        .optional(),
+    value: core.serialization.list(ChatMessageRequest_1.ChatMessageRequest).optional(),
 });

package/dist/serialization/types/NamedTestCaseErrorVariableValueRequest.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { VellumErrorRequest } from "./VellumErrorRequest";
 export declare const NamedTestCaseErrorVariableValueRequest: core.serialization.ObjectSchema<serializers.NamedTestCaseErrorVariableValueRequest.Raw, Vellum.NamedTestCaseErrorVariableValueRequest>;
 export declare namespace NamedTestCaseErrorVariableValueRequest {
     interface Raw {
         name: string;
-        value?: serializers.VellumErrorRequest.Raw | null;
+        value?: VellumErrorRequest.Raw | null;
     }
 }

package/dist/serialization/types/NamedTestCaseErrorVariableValueRequest.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NamedTestCaseErrorVariableValueRequest = void 0;
 const core = __importStar(require("../../core"));
+const VellumErrorRequest_1 = require("./VellumErrorRequest");
 exports.NamedTestCaseErrorVariableValueRequest = core.serialization.object({
     name: core.serialization.string(),
-    value: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumErrorRequest; })).optional(),
+    value: VellumErrorRequest_1.VellumErrorRequest.optional(),
 });

package/dist/serialization/types/NamedTestCaseSearchResultsVariableValueRequest.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SearchResultRequest } from "./SearchResultRequest";
 export declare const NamedTestCaseSearchResultsVariableValueRequest: core.serialization.ObjectSchema<serializers.NamedTestCaseSearchResultsVariableValueRequest.Raw, Vellum.NamedTestCaseSearchResultsVariableValueRequest>;
 export declare namespace NamedTestCaseSearchResultsVariableValueRequest {
     interface Raw {
         name: string;
-        value?: serializers.SearchResultRequest.Raw[] | null;
+        value?: SearchResultRequest.Raw[] | null;
     }
 }

package/dist/serialization/types/NamedTestCaseSearchResultsVariableValueRequest.js

@@ -25,21 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NamedTestCaseSearchResultsVariableValueRequest = void 0;
 const core = __importStar(require("../../core"));
+const SearchResultRequest_1 = require("./SearchResultRequest");
 exports.NamedTestCaseSearchResultsVariableValueRequest = core.serialization.object({
     name: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SearchResultRequest; })))
-        .optional(),
+    value: core.serialization.list(SearchResultRequest_1.SearchResultRequest).optional(),
 });

package/dist/serialization/types/NamedTestCaseVariableValueRequest.d.ts

@@ -4,25 +4,31 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { NamedTestCaseStringVariableValueRequest } from "./NamedTestCaseStringVariableValueRequest";
+import { NamedTestCaseNumberVariableValueRequest } from "./NamedTestCaseNumberVariableValueRequest";
+import { NamedTestCaseJsonVariableValueRequest } from "./NamedTestCaseJsonVariableValueRequest";
+import { NamedTestCaseChatHistoryVariableValueRequest } from "./NamedTestCaseChatHistoryVariableValueRequest";
+import { NamedTestCaseSearchResultsVariableValueRequest } from "./NamedTestCaseSearchResultsVariableValueRequest";
+import { NamedTestCaseErrorVariableValueRequest } from "./NamedTestCaseErrorVariableValueRequest";
 export declare const NamedTestCaseVariableValueRequest: core.serialization.Schema<serializers.NamedTestCaseVariableValueRequest.Raw, Vellum.NamedTestCaseVariableValueRequest>;
 export declare namespace NamedTestCaseVariableValueRequest {
     type Raw = NamedTestCaseVariableValueRequest.String | NamedTestCaseVariableValueRequest.Number | NamedTestCaseVariableValueRequest.Json | NamedTestCaseVariableValueRequest.ChatHistory | NamedTestCaseVariableValueRequest.SearchResults | NamedTestCaseVariableValueRequest.Error;
-    interface String extends serializers.NamedTestCaseStringVariableValueRequest.Raw {
+    interface String extends NamedTestCaseStringVariableValueRequest.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.NamedTestCaseNumberVariableValueRequest.Raw {
+    interface Number extends NamedTestCaseNumberVariableValueRequest.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.NamedTestCaseJsonVariableValueRequest.Raw {
+    interface Json extends NamedTestCaseJsonVariableValueRequest.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.NamedTestCaseChatHistoryVariableValueRequest.Raw {
+    interface ChatHistory extends NamedTestCaseChatHistoryVariableValueRequest.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.NamedTestCaseSearchResultsVariableValueRequest.Raw {
+    interface SearchResults extends NamedTestCaseSearchResultsVariableValueRequest.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Error extends serializers.NamedTestCaseErrorVariableValueRequest.Raw {
+    interface Error extends NamedTestCaseErrorVariableValueRequest.Raw {
         type: "ERROR";
     }
 }

package/dist/serialization/types/NamedTestCaseVariableValueRequest.js

@@ -25,26 +25,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NamedTestCaseVariableValueRequest = void 0;
 const core = __importStar(require("../../core"));
+const NamedTestCaseStringVariableValueRequest_1 = require("./NamedTestCaseStringVariableValueRequest");
+const NamedTestCaseNumberVariableValueRequest_1 = require("./NamedTestCaseNumberVariableValueRequest");
+const NamedTestCaseJsonVariableValueRequest_1 = require("./NamedTestCaseJsonVariableValueRequest");
+const NamedTestCaseChatHistoryVariableValueRequest_1 = require("./NamedTestCaseChatHistoryVariableValueRequest");
+const NamedTestCaseSearchResultsVariableValueRequest_1 = require("./NamedTestCaseSearchResultsVariableValueRequest");
+const NamedTestCaseErrorVariableValueRequest_1 = require("./NamedTestCaseErrorVariableValueRequest");
 exports.NamedTestCaseVariableValueRequest = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NamedTestCaseStringVariableValueRequest; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NamedTestCaseNumberVariableValueRequest; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NamedTestCaseJsonVariableValueRequest; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NamedTestCaseChatHistoryVariableValueRequest; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NamedTestCaseSearchResultsVariableValueRequest; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NamedTestCaseErrorVariableValueRequest; })),
+    STRING: NamedTestCaseStringVariableValueRequest_1.NamedTestCaseStringVariableValueRequest,
+    NUMBER: NamedTestCaseNumberVariableValueRequest_1.NamedTestCaseNumberVariableValueRequest,
+    JSON: NamedTestCaseJsonVariableValueRequest_1.NamedTestCaseJsonVariableValueRequest,
+    CHAT_HISTORY: NamedTestCaseChatHistoryVariableValueRequest_1.NamedTestCaseChatHistoryVariableValueRequest,
+    SEARCH_RESULTS: NamedTestCaseSearchResultsVariableValueRequest_1.NamedTestCaseSearchResultsVariableValueRequest,
+    ERROR: NamedTestCaseErrorVariableValueRequest_1.NamedTestCaseErrorVariableValueRequest,
 })
     .transform({
     transform: (value) => value,

package/dist/serialization/types/NodeInputCompiledArrayValue.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ArrayVariableValueItem } from "./ArrayVariableValueItem";
 export declare const NodeInputCompiledArrayValue: core.serialization.ObjectSchema<serializers.NodeInputCompiledArrayValue.Raw, Vellum.NodeInputCompiledArrayValue>;
 export declare namespace NodeInputCompiledArrayValue {
     interface Raw {
         node_input_id: string;
         key: string;
-        value?: serializers.ArrayVariableValueItem.Raw[] | null;
+        value?: ArrayVariableValueItem.Raw[] | null;
     }
 }

package/dist/serialization/types/NodeInputCompiledArrayValue.js

@@ -25,22 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeInputCompiledArrayValue = void 0;
 const core = __importStar(require("../../core"));
+const ArrayVariableValueItem_1 = require("./ArrayVariableValueItem");
 exports.NodeInputCompiledArrayValue = core.serialization.object({
     nodeInputId: core.serialization.property("node_input_id", core.serialization.string()),
     key: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ArrayVariableValueItem; })))
-        .optional(),
+    value: core.serialization.list(ArrayVariableValueItem_1.ArrayVariableValueItem).optional(),
 });

package/dist/serialization/types/NodeInputCompiledChatHistoryValue.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessage } from "./ChatMessage";
 export declare const NodeInputCompiledChatHistoryValue: core.serialization.ObjectSchema<serializers.NodeInputCompiledChatHistoryValue.Raw, Vellum.NodeInputCompiledChatHistoryValue>;
 export declare namespace NodeInputCompiledChatHistoryValue {
     interface Raw {
         node_input_id: string;
         key: string;
-        value?: serializers.ChatMessage.Raw[] | null;
+        value?: ChatMessage.Raw[] | null;
     }
 }

package/dist/serialization/types/NodeInputCompiledChatHistoryValue.js

@@ -25,22 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeInputCompiledChatHistoryValue = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessage_1 = require("./ChatMessage");
 exports.NodeInputCompiledChatHistoryValue = core.serialization.object({
     nodeInputId: core.serialization.property("node_input_id", core.serialization.string()),
     key: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessage; })))
-        .optional(),
+    value: core.serialization.list(ChatMessage_1.ChatMessage).optional(),
 });

package/dist/serialization/types/NodeInputCompiledErrorValue.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { VellumError } from "./VellumError";
 export declare const NodeInputCompiledErrorValue: core.serialization.ObjectSchema<serializers.NodeInputCompiledErrorValue.Raw, Vellum.NodeInputCompiledErrorValue>;
 export declare namespace NodeInputCompiledErrorValue {
     interface Raw {
         node_input_id: string;
         key: string;
-        value?: serializers.VellumError.Raw | null;
+        value?: VellumError.Raw | null;
     }
 }

package/dist/serialization/types/NodeInputCompiledErrorValue.js

@@ -25,20 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeInputCompiledErrorValue = void 0;
 const core = __importStar(require("../../core"));
+const VellumError_1 = require("./VellumError");
 exports.NodeInputCompiledErrorValue = core.serialization.object({
     nodeInputId: core.serialization.property("node_input_id", core.serialization.string()),
     key: core.serialization.string(),
-    value: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumError; })).optional(),
+    value: VellumError_1.VellumError.optional(),
 });

package/dist/serialization/types/NodeInputCompiledFunctionCall.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "..";
+import * as Vellum from "../../api";
+import * as core from "../../core";
+import { FunctionCall } from "./FunctionCall";
+export declare const NodeInputCompiledFunctionCall: core.serialization.ObjectSchema<serializers.NodeInputCompiledFunctionCall.Raw, Vellum.NodeInputCompiledFunctionCall>;
+export declare namespace NodeInputCompiledFunctionCall {
+    interface Raw {
+        node_input_id: string;
+        key: string;
+        value?: FunctionCall.Raw | null;
+    }
+}

package/dist/serialization/types/NodeInputCompiledFunctionCall.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeInputCompiledFunctionCall = void 0;
+const core = __importStar(require("../../core"));
+const FunctionCall_1 = require("./FunctionCall");
+exports.NodeInputCompiledFunctionCall = core.serialization.object({
+    nodeInputId: core.serialization.property("node_input_id", core.serialization.string()),
+    key: core.serialization.string(),
+    value: FunctionCall_1.FunctionCall.optional(),
+});

package/dist/serialization/types/NodeInputCompiledSearchResultsValue.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SearchResult } from "./SearchResult";
 export declare const NodeInputCompiledSearchResultsValue: core.serialization.ObjectSchema<serializers.NodeInputCompiledSearchResultsValue.Raw, Vellum.NodeInputCompiledSearchResultsValue>;
 export declare namespace NodeInputCompiledSearchResultsValue {
     interface Raw {
         node_input_id: string;
         key: string;
-        value?: serializers.SearchResult.Raw[] | null;
+        value?: SearchResult.Raw[] | null;
     }
 }

package/dist/serialization/types/NodeInputCompiledSearchResultsValue.js

@@ -25,22 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeInputCompiledSearchResultsValue = void 0;
 const core = __importStar(require("../../core"));
+const SearchResult_1 = require("./SearchResult");
 exports.NodeInputCompiledSearchResultsValue = core.serialization.object({
     nodeInputId: core.serialization.property("node_input_id", core.serialization.string()),
     key: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SearchResult; })))
-        .optional(),
+    value: core.serialization.list(SearchResult_1.SearchResult).optional(),
 });

package/dist/serialization/types/NodeInputVariableCompiledValue.d.ts

@@ -4,28 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { NodeInputCompiledStringValue } from "./NodeInputCompiledStringValue";
+import { NodeInputCompiledNumberValue } from "./NodeInputCompiledNumberValue";
+import { NodeInputCompiledJsonValue } from "./NodeInputCompiledJsonValue";
+import { NodeInputCompiledChatHistoryValue } from "./NodeInputCompiledChatHistoryValue";
+import { NodeInputCompiledSearchResultsValue } from "./NodeInputCompiledSearchResultsValue";
+import { NodeInputCompiledErrorValue } from "./NodeInputCompiledErrorValue";
+import { NodeInputCompiledArrayValue } from "./NodeInputCompiledArrayValue";
+import { NodeInputCompiledFunctionCall } from "./NodeInputCompiledFunctionCall";
 export declare const NodeInputVariableCompiledValue: core.serialization.Schema<serializers.NodeInputVariableCompiledValue.Raw, Vellum.NodeInputVariableCompiledValue>;
 export declare namespace NodeInputVariableCompiledValue {
-    type Raw = NodeInputVariableCompiledValue.String | NodeInputVariableCompiledValue.Number | NodeInputVariableCompiledValue.Json | NodeInputVariableCompiledValue.ChatHistory | NodeInputVariableCompiledValue.SearchResults | NodeInputVariableCompiledValue.Error | NodeInputVariableCompiledValue.Array;
-    interface String extends serializers.NodeInputCompiledStringValue.Raw {
+    type Raw = NodeInputVariableCompiledValue.String | NodeInputVariableCompiledValue.Number | NodeInputVariableCompiledValue.Json | NodeInputVariableCompiledValue.ChatHistory | NodeInputVariableCompiledValue.SearchResults | NodeInputVariableCompiledValue.Error | NodeInputVariableCompiledValue.Array | NodeInputVariableCompiledValue.FunctionCall;
+    interface String extends NodeInputCompiledStringValue.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.NodeInputCompiledNumberValue.Raw {
+    interface Number extends NodeInputCompiledNumberValue.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.NodeInputCompiledJsonValue.Raw {
+    interface Json extends NodeInputCompiledJsonValue.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.NodeInputCompiledChatHistoryValue.Raw {
+    interface ChatHistory extends NodeInputCompiledChatHistoryValue.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.NodeInputCompiledSearchResultsValue.Raw {
+    interface SearchResults extends NodeInputCompiledSearchResultsValue.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Error extends serializers.NodeInputCompiledErrorValue.Raw {
+    interface Error extends NodeInputCompiledErrorValue.Raw {
         type: "ERROR";
     }
-    interface Array extends serializers.NodeInputCompiledArrayValue.Raw {
+    interface Array extends NodeInputCompiledArrayValue.Raw {
         type: "ARRAY";
     }
+    interface FunctionCall extends NodeInputCompiledFunctionCall.Raw {
+        type: "FUNCTION_CALL";
+    }
 }

package/dist/serialization/types/NodeInputVariableCompiledValue.js

@@ -25,27 +25,27 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeInputVariableCompiledValue = void 0;
 const core = __importStar(require("../../core"));
+const NodeInputCompiledStringValue_1 = require("./NodeInputCompiledStringValue");
+const NodeInputCompiledNumberValue_1 = require("./NodeInputCompiledNumberValue");
+const NodeInputCompiledJsonValue_1 = require("./NodeInputCompiledJsonValue");
+const NodeInputCompiledChatHistoryValue_1 = require("./NodeInputCompiledChatHistoryValue");
+const NodeInputCompiledSearchResultsValue_1 = require("./NodeInputCompiledSearchResultsValue");
+const NodeInputCompiledErrorValue_1 = require("./NodeInputCompiledErrorValue");
+const NodeInputCompiledArrayValue_1 = require("./NodeInputCompiledArrayValue");
+const NodeInputCompiledFunctionCall_1 = require("./NodeInputCompiledFunctionCall");
 exports.NodeInputVariableCompiledValue = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeInputCompiledStringValue; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeInputCompiledNumberValue; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeInputCompiledJsonValue; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeInputCompiledChatHistoryValue; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeInputCompiledSearchResultsValue; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeInputCompiledErrorValue; })),
-    ARRAY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeInputCompiledArrayValue; })),
+    STRING: NodeInputCompiledStringValue_1.NodeInputCompiledStringValue,
+    NUMBER: NodeInputCompiledNumberValue_1.NodeInputCompiledNumberValue,
+    JSON: NodeInputCompiledJsonValue_1.NodeInputCompiledJsonValue,
+    CHAT_HISTORY: NodeInputCompiledChatHistoryValue_1.NodeInputCompiledChatHistoryValue,
+    SEARCH_RESULTS: NodeInputCompiledSearchResultsValue_1.NodeInputCompiledSearchResultsValue,
+    ERROR: NodeInputCompiledErrorValue_1.NodeInputCompiledErrorValue,
+    ARRAY: NodeInputCompiledArrayValue_1.NodeInputCompiledArrayValue,
+    FUNCTION_CALL: NodeInputCompiledFunctionCall_1.NodeInputCompiledFunctionCall,
 })
     .transform({
     transform: (value) => value,

package/dist/serialization/types/NodeOutputCompiledArrayValue.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ArrayVariableValueItem } from "./ArrayVariableValueItem";
 export declare const NodeOutputCompiledArrayValue: core.serialization.ObjectSchema<serializers.NodeOutputCompiledArrayValue.Raw, Vellum.NodeOutputCompiledArrayValue>;
 export declare namespace NodeOutputCompiledArrayValue {
     interface Raw {
         node_output_id: string;
-        value?: serializers.ArrayVariableValueItem.Raw[] | null;
+        value?: ArrayVariableValueItem.Raw[] | null;
     }
 }

package/dist/serialization/types/NodeOutputCompiledArrayValue.js

@@ -25,21 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeOutputCompiledArrayValue = void 0;
 const core = __importStar(require("../../core"));
+const ArrayVariableValueItem_1 = require("./ArrayVariableValueItem");
 exports.NodeOutputCompiledArrayValue = core.serialization.object({
     nodeOutputId: core.serialization.property("node_output_id", core.serialization.string()),
-    value: core.serialization
-        .list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ArrayVariableValueItem; })))
-        .optional(),
+    value: core.serialization.list(ArrayVariableValueItem_1.ArrayVariableValueItem).optional(),
 });

package/dist/serialization/types/NodeOutputCompiledChatHistoryValue.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessage } from "./ChatMessage";
 export declare const NodeOutputCompiledChatHistoryValue: core.serialization.ObjectSchema<serializers.NodeOutputCompiledChatHistoryValue.Raw, Vellum.NodeOutputCompiledChatHistoryValue>;
 export declare namespace NodeOutputCompiledChatHistoryValue {
     interface Raw {
         node_output_id: string;
-        value?: serializers.ChatMessage.Raw[] | null;
+        value?: ChatMessage.Raw[] | null;
     }
 }

package/dist/serialization/types/NodeOutputCompiledChatHistoryValue.js

@@ -25,21 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeOutputCompiledChatHistoryValue = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessage_1 = require("./ChatMessage");
 exports.NodeOutputCompiledChatHistoryValue = core.serialization.object({
     nodeOutputId: core.serialization.property("node_output_id", core.serialization.string()),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessage; })))
-        .optional(),
+    value: core.serialization.list(ChatMessage_1.ChatMessage).optional(),
 });