vellum-ai 0.3.14 → 0.3.15

package/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/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/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/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/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/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/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/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/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/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/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/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/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/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(),
 });

package/serialization/types/NodeOutputCompiledErrorValue.d.ts

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

package/serialization/types/NodeOutputCompiledErrorValue.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.NodeOutputCompiledErrorValue = void 0;
 const core = __importStar(require("../../core"));
+const VellumError_1 = require("./VellumError");
 exports.NodeOutputCompiledErrorValue = core.serialization.object({
     nodeOutputId: core.serialization.property("node_output_id", 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/serialization/types/NodeOutputCompiledFunctionValue.d.ts

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

package/serialization/types/NodeOutputCompiledFunctionValue.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.NodeOutputCompiledFunctionValue = void 0;
 const core = __importStar(require("../../core"));
+const FunctionCall_1 = require("./FunctionCall");
 exports.NodeOutputCompiledFunctionValue = core.serialization.object({
     nodeOutputId: core.serialization.property("node_output_id", core.serialization.string()),
-    value: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FunctionCall; })).optional(),
+    value: FunctionCall_1.FunctionCall.optional(),
 });

package/serialization/types/NodeOutputCompiledSearchResultsValue.d.ts

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

package/serialization/types/NodeOutputCompiledSearchResultsValue.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.NodeOutputCompiledSearchResultsValue = void 0;
 const core = __importStar(require("../../core"));
+const SearchResult_1 = require("./SearchResult");
 exports.NodeOutputCompiledSearchResultsValue = 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("..")))).SearchResult; })))
-        .optional(),
+    value: core.serialization.list(SearchResult_1.SearchResult).optional(),
 });

package/serialization/types/NodeOutputCompiledValue.d.ts

@@ -4,31 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { NodeOutputCompiledStringValue } from "./NodeOutputCompiledStringValue";
+import { NodeOutputCompiledNumberValue } from "./NodeOutputCompiledNumberValue";
+import { NodeOutputCompiledJsonValue } from "./NodeOutputCompiledJsonValue";
+import { NodeOutputCompiledChatHistoryValue } from "./NodeOutputCompiledChatHistoryValue";
+import { NodeOutputCompiledSearchResultsValue } from "./NodeOutputCompiledSearchResultsValue";
+import { NodeOutputCompiledErrorValue } from "./NodeOutputCompiledErrorValue";
+import { NodeOutputCompiledArrayValue } from "./NodeOutputCompiledArrayValue";
+import { NodeOutputCompiledFunctionValue } from "./NodeOutputCompiledFunctionValue";
 export declare const NodeOutputCompiledValue: core.serialization.Schema<serializers.NodeOutputCompiledValue.Raw, Vellum.NodeOutputCompiledValue>;
 export declare namespace NodeOutputCompiledValue {
     type Raw = NodeOutputCompiledValue.String | NodeOutputCompiledValue.Number | NodeOutputCompiledValue.Json | NodeOutputCompiledValue.ChatHistory | NodeOutputCompiledValue.SearchResults | NodeOutputCompiledValue.Error | NodeOutputCompiledValue.Array | NodeOutputCompiledValue.FunctionCall;
-    interface String extends serializers.NodeOutputCompiledStringValue.Raw {
+    interface String extends NodeOutputCompiledStringValue.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.NodeOutputCompiledNumberValue.Raw {
+    interface Number extends NodeOutputCompiledNumberValue.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.NodeOutputCompiledJsonValue.Raw {
+    interface Json extends NodeOutputCompiledJsonValue.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.NodeOutputCompiledChatHistoryValue.Raw {
+    interface ChatHistory extends NodeOutputCompiledChatHistoryValue.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.NodeOutputCompiledSearchResultsValue.Raw {
+    interface SearchResults extends NodeOutputCompiledSearchResultsValue.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Error extends serializers.NodeOutputCompiledErrorValue.Raw {
+    interface Error extends NodeOutputCompiledErrorValue.Raw {
         type: "ERROR";
     }
-    interface Array extends serializers.NodeOutputCompiledArrayValue.Raw {
+    interface Array extends NodeOutputCompiledArrayValue.Raw {
         type: "ARRAY";
     }
-    interface FunctionCall extends serializers.NodeOutputCompiledFunctionValue.Raw {
+    interface FunctionCall extends NodeOutputCompiledFunctionValue.Raw {
         type: "FUNCTION_CALL";
     }
 }

package/serialization/types/NodeOutputCompiledValue.js

@@ -25,28 +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.NodeOutputCompiledValue = void 0;
 const core = __importStar(require("../../core"));
+const NodeOutputCompiledStringValue_1 = require("./NodeOutputCompiledStringValue");
+const NodeOutputCompiledNumberValue_1 = require("./NodeOutputCompiledNumberValue");
+const NodeOutputCompiledJsonValue_1 = require("./NodeOutputCompiledJsonValue");
+const NodeOutputCompiledChatHistoryValue_1 = require("./NodeOutputCompiledChatHistoryValue");
+const NodeOutputCompiledSearchResultsValue_1 = require("./NodeOutputCompiledSearchResultsValue");
+const NodeOutputCompiledErrorValue_1 = require("./NodeOutputCompiledErrorValue");
+const NodeOutputCompiledArrayValue_1 = require("./NodeOutputCompiledArrayValue");
+const NodeOutputCompiledFunctionValue_1 = require("./NodeOutputCompiledFunctionValue");
 exports.NodeOutputCompiledValue = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledStringValue; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledNumberValue; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledJsonValue; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledChatHistoryValue; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledSearchResultsValue; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledErrorValue; })),
-    ARRAY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledArrayValue; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledFunctionValue; })),
+    STRING: NodeOutputCompiledStringValue_1.NodeOutputCompiledStringValue,
+    NUMBER: NodeOutputCompiledNumberValue_1.NodeOutputCompiledNumberValue,
+    JSON: NodeOutputCompiledJsonValue_1.NodeOutputCompiledJsonValue,
+    CHAT_HISTORY: NodeOutputCompiledChatHistoryValue_1.NodeOutputCompiledChatHistoryValue,
+    SEARCH_RESULTS: NodeOutputCompiledSearchResultsValue_1.NodeOutputCompiledSearchResultsValue,
+    ERROR: NodeOutputCompiledErrorValue_1.NodeOutputCompiledErrorValue,
+    ARRAY: NodeOutputCompiledArrayValue_1.NodeOutputCompiledArrayValue,
+    FUNCTION_CALL: NodeOutputCompiledFunctionValue_1.NodeOutputCompiledFunctionValue,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/NormalizedLogProbs.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { NormalizedTokenLogProbs } from "./NormalizedTokenLogProbs";
 export declare const NormalizedLogProbs: core.serialization.ObjectSchema<serializers.NormalizedLogProbs.Raw, Vellum.NormalizedLogProbs>;
 export declare namespace NormalizedLogProbs {
     interface Raw {
-        tokens: serializers.NormalizedTokenLogProbs.Raw[];
+        tokens: NormalizedTokenLogProbs.Raw[];
         likelihood?: number | null;
     }
 }

package/serialization/types/NormalizedLogProbs.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.NormalizedLogProbs = void 0;
 const core = __importStar(require("../../core"));
+const NormalizedTokenLogProbs_1 = require("./NormalizedTokenLogProbs");
 exports.NormalizedLogProbs = core.serialization.object({
-    tokens: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NormalizedTokenLogProbs; }))),
+    tokens: core.serialization.list(NormalizedTokenLogProbs_1.NormalizedTokenLogProbs),
     likelihood: core.serialization.number().optional(),
 });

package/serialization/types/PaginatedDocumentIndexReadList.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { DocumentIndexRead } from "./DocumentIndexRead";
 export declare const PaginatedDocumentIndexReadList: core.serialization.ObjectSchema<serializers.PaginatedDocumentIndexReadList.Raw, Vellum.PaginatedDocumentIndexReadList>;
 export declare namespace PaginatedDocumentIndexReadList {
     interface Raw {
         count?: number | null;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.DocumentIndexRead.Raw[] | null;
+        results?: DocumentIndexRead.Raw[] | null;
     }
 }