vellum-ai 0.3.14 → 0.3.16

package/serialization/types/ErrorVariableValue.js

@@ -25,18 +25,10 @@ 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.ErrorVariableValue = void 0;
 const core = __importStar(require("../../core"));
+const VellumError_1 = require("./VellumError");
 exports.ErrorVariableValue = core.serialization.object({
-    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/ExecutePromptEvent.d.ts

@@ -4,19 +4,23 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { InitiatedExecutePromptEvent } from "./InitiatedExecutePromptEvent";
+import { StreamingExecutePromptEvent } from "./StreamingExecutePromptEvent";
+import { FulfilledExecutePromptEvent } from "./FulfilledExecutePromptEvent";
+import { RejectedExecutePromptEvent } from "./RejectedExecutePromptEvent";
 export declare const ExecutePromptEvent: core.serialization.Schema<serializers.ExecutePromptEvent.Raw, Vellum.ExecutePromptEvent>;
 export declare namespace ExecutePromptEvent {
     type Raw = ExecutePromptEvent.Initiated | ExecutePromptEvent.Streaming | ExecutePromptEvent.Fulfilled | ExecutePromptEvent.Rejected;
-    interface Initiated extends serializers.InitiatedExecutePromptEvent.Raw {
+    interface Initiated extends InitiatedExecutePromptEvent.Raw {
         state: "INITIATED";
     }
-    interface Streaming extends serializers.StreamingExecutePromptEvent.Raw {
+    interface Streaming extends StreamingExecutePromptEvent.Raw {
         state: "STREAMING";
     }
-    interface Fulfilled extends serializers.FulfilledExecutePromptEvent.Raw {
+    interface Fulfilled extends FulfilledExecutePromptEvent.Raw {
         state: "FULFILLED";
     }
-    interface Rejected extends serializers.RejectedExecutePromptEvent.Raw {
+    interface Rejected extends RejectedExecutePromptEvent.Raw {
         state: "REJECTED";
     }
 }

package/serialization/types/ExecutePromptEvent.js

@@ -25,24 +25,19 @@ 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.ExecutePromptEvent = void 0;
 const core = __importStar(require("../../core"));
+const InitiatedExecutePromptEvent_1 = require("./InitiatedExecutePromptEvent");
+const StreamingExecutePromptEvent_1 = require("./StreamingExecutePromptEvent");
+const FulfilledExecutePromptEvent_1 = require("./FulfilledExecutePromptEvent");
+const RejectedExecutePromptEvent_1 = require("./RejectedExecutePromptEvent");
 exports.ExecutePromptEvent = core.serialization
     .union("state", {
-    INITIATED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).InitiatedExecutePromptEvent; })),
-    STREAMING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StreamingExecutePromptEvent; })),
-    FULFILLED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FulfilledExecutePromptEvent; })),
-    REJECTED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RejectedExecutePromptEvent; })),
+    INITIATED: InitiatedExecutePromptEvent_1.InitiatedExecutePromptEvent,
+    STREAMING: StreamingExecutePromptEvent_1.StreamingExecutePromptEvent,
+    FULFILLED: FulfilledExecutePromptEvent_1.FulfilledExecutePromptEvent,
+    REJECTED: RejectedExecutePromptEvent_1.RejectedExecutePromptEvent,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/ExecutePromptResponse.d.ts

@@ -4,13 +4,15 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { FulfilledExecutePromptResponse } from "./FulfilledExecutePromptResponse";
+import { RejectedExecutePromptResponse } from "./RejectedExecutePromptResponse";
 export declare const ExecutePromptResponse: core.serialization.Schema<serializers.ExecutePromptResponse.Raw, Vellum.ExecutePromptResponse>;
 export declare namespace ExecutePromptResponse {
     type Raw = ExecutePromptResponse.Fulfilled | ExecutePromptResponse.Rejected;
-    interface Fulfilled extends serializers.FulfilledExecutePromptResponse.Raw {
+    interface Fulfilled extends FulfilledExecutePromptResponse.Raw {
         state: "FULFILLED";
     }
-    interface Rejected extends serializers.RejectedExecutePromptResponse.Raw {
+    interface Rejected extends RejectedExecutePromptResponse.Raw {
         state: "REJECTED";
     }
 }

package/serialization/types/ExecutePromptResponse.js

@@ -25,22 +25,15 @@ 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.ExecutePromptResponse = void 0;
 const core = __importStar(require("../../core"));
+const FulfilledExecutePromptResponse_1 = require("./FulfilledExecutePromptResponse");
+const RejectedExecutePromptResponse_1 = require("./RejectedExecutePromptResponse");
 exports.ExecutePromptResponse = core.serialization
     .union("state", {
-    FULFILLED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FulfilledExecutePromptResponse; })),
-    REJECTED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RejectedExecutePromptResponse; })),
+    FULFILLED: FulfilledExecutePromptResponse_1.FulfilledExecutePromptResponse,
+    REJECTED: RejectedExecutePromptResponse_1.RejectedExecutePromptResponse,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/ExecuteWorkflowResponse.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ExecuteWorkflowWorkflowResultEvent } from "./ExecuteWorkflowWorkflowResultEvent";
 export declare const ExecuteWorkflowResponse: core.serialization.ObjectSchema<serializers.ExecuteWorkflowResponse.Raw, Vellum.ExecuteWorkflowResponse>;
 export declare namespace ExecuteWorkflowResponse {
     interface Raw {
         execution_id: string;
         run_id?: string | null;
         external_id?: string | null;
-        data: serializers.ExecuteWorkflowWorkflowResultEvent.Raw;
+        data: ExecuteWorkflowWorkflowResultEvent.Raw;
     }
 }

package/serialization/types/ExecuteWorkflowResponse.js

@@ -25,21 +25,13 @@ 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.ExecuteWorkflowResponse = void 0;
 const core = __importStar(require("../../core"));
+const ExecuteWorkflowWorkflowResultEvent_1 = require("./ExecuteWorkflowWorkflowResultEvent");
 exports.ExecuteWorkflowResponse = core.serialization.object({
     executionId: core.serialization.property("execution_id", core.serialization.string()),
     runId: core.serialization.property("run_id", core.serialization.string().optional()),
     externalId: core.serialization.property("external_id", core.serialization.string().optional()),
-    data: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecuteWorkflowWorkflowResultEvent; })),
+    data: ExecuteWorkflowWorkflowResultEvent_1.ExecuteWorkflowWorkflowResultEvent,
 });

package/serialization/types/ExecuteWorkflowWorkflowResultEvent.d.ts

@@ -4,13 +4,15 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { FulfilledExecuteWorkflowWorkflowResultEvent } from "./FulfilledExecuteWorkflowWorkflowResultEvent";
+import { RejectedExecuteWorkflowWorkflowResultEvent } from "./RejectedExecuteWorkflowWorkflowResultEvent";
 export declare const ExecuteWorkflowWorkflowResultEvent: core.serialization.Schema<serializers.ExecuteWorkflowWorkflowResultEvent.Raw, Vellum.ExecuteWorkflowWorkflowResultEvent>;
 export declare namespace ExecuteWorkflowWorkflowResultEvent {
     type Raw = ExecuteWorkflowWorkflowResultEvent.Fulfilled | ExecuteWorkflowWorkflowResultEvent.Rejected;
-    interface Fulfilled extends serializers.FulfilledExecuteWorkflowWorkflowResultEvent.Raw {
+    interface Fulfilled extends FulfilledExecuteWorkflowWorkflowResultEvent.Raw {
         state: "FULFILLED";
     }
-    interface Rejected extends serializers.RejectedExecuteWorkflowWorkflowResultEvent.Raw {
+    interface Rejected extends RejectedExecuteWorkflowWorkflowResultEvent.Raw {
         state: "REJECTED";
     }
 }

package/serialization/types/ExecuteWorkflowWorkflowResultEvent.js

@@ -25,22 +25,15 @@ 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.ExecuteWorkflowWorkflowResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const FulfilledExecuteWorkflowWorkflowResultEvent_1 = require("./FulfilledExecuteWorkflowWorkflowResultEvent");
+const RejectedExecuteWorkflowWorkflowResultEvent_1 = require("./RejectedExecuteWorkflowWorkflowResultEvent");
 exports.ExecuteWorkflowWorkflowResultEvent = core.serialization
     .union("state", {
-    FULFILLED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FulfilledExecuteWorkflowWorkflowResultEvent; })),
-    REJECTED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RejectedExecuteWorkflowWorkflowResultEvent; })),
+    FULFILLED: FulfilledExecuteWorkflowWorkflowResultEvent_1.FulfilledExecuteWorkflowWorkflowResultEvent,
+    REJECTED: RejectedExecuteWorkflowWorkflowResultEvent_1.RejectedExecuteWorkflowWorkflowResultEvent,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/ExecutionArrayVellumValue.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 ExecutionArrayVellumValue: core.serialization.ObjectSchema<serializers.ExecutionArrayVellumValue.Raw, Vellum.ExecutionArrayVellumValue>;
 export declare namespace ExecutionArrayVellumValue {
     interface Raw {
         id: string;
         name: string;
-        value?: serializers.ArrayVariableValueItem.Raw[] | null;
+        value?: ArrayVariableValueItem.Raw[] | null;
     }
 }

package/serialization/types/ExecutionArrayVellumValue.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.ExecutionArrayVellumValue = void 0;
 const core = __importStar(require("../../core"));
+const ArrayVariableValueItem_1 = require("./ArrayVariableValueItem");
 exports.ExecutionArrayVellumValue = core.serialization.object({
     id: core.serialization.string(),
     name: 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/ExecutionChatHistoryVellumValue.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 ExecutionChatHistoryVellumValue: core.serialization.ObjectSchema<serializers.ExecutionChatHistoryVellumValue.Raw, Vellum.ExecutionChatHistoryVellumValue>;
 export declare namespace ExecutionChatHistoryVellumValue {
     interface Raw {
         id: string;
         name: string;
-        value?: serializers.ChatMessage.Raw[] | null;
+        value?: ChatMessage.Raw[] | null;
     }
 }

package/serialization/types/ExecutionChatHistoryVellumValue.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.ExecutionChatHistoryVellumValue = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessage_1 = require("./ChatMessage");
 exports.ExecutionChatHistoryVellumValue = core.serialization.object({
     id: core.serialization.string(),
     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("..")))).ChatMessage; })))
-        .optional(),
+    value: core.serialization.list(ChatMessage_1.ChatMessage).optional(),
 });

package/serialization/types/ExecutionErrorVellumValue.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 ExecutionErrorVellumValue: core.serialization.ObjectSchema<serializers.ExecutionErrorVellumValue.Raw, Vellum.ExecutionErrorVellumValue>;
 export declare namespace ExecutionErrorVellumValue {
     interface Raw {
         id: string;
         name: string;
-        value?: serializers.VellumError.Raw | null;
+        value?: VellumError.Raw | null;
     }
 }

package/serialization/types/ExecutionErrorVellumValue.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.ExecutionErrorVellumValue = void 0;
 const core = __importStar(require("../../core"));
+const VellumError_1 = require("./VellumError");
 exports.ExecutionErrorVellumValue = core.serialization.object({
     id: core.serialization.string(),
     name: 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/ExecutionFunctionCallVellumValue.d.ts

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

package/serialization/types/ExecutionFunctionCallVellumValue.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.ExecutionFunctionCallVellumValue = void 0;
 const core = __importStar(require("../../core"));
+const FunctionCall_1 = require("./FunctionCall");
 exports.ExecutionFunctionCallVellumValue = core.serialization.object({
     id: core.serialization.string(),
     name: 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/ExecutionSearchResultsVellumValue.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 ExecutionSearchResultsVellumValue: core.serialization.ObjectSchema<serializers.ExecutionSearchResultsVellumValue.Raw, Vellum.ExecutionSearchResultsVellumValue>;
 export declare namespace ExecutionSearchResultsVellumValue {
     interface Raw {
         id: string;
         name: string;
-        value?: serializers.SearchResult.Raw[] | null;
+        value?: SearchResult.Raw[] | null;
     }
 }

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

package/serialization/types/ExecutionVellumValue.d.ts

@@ -4,31 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ExecutionStringVellumValue } from "./ExecutionStringVellumValue";
+import { ExecutionNumberVellumValue } from "./ExecutionNumberVellumValue";
+import { ExecutionJsonVellumValue } from "./ExecutionJsonVellumValue";
+import { ExecutionChatHistoryVellumValue } from "./ExecutionChatHistoryVellumValue";
+import { ExecutionSearchResultsVellumValue } from "./ExecutionSearchResultsVellumValue";
+import { ExecutionErrorVellumValue } from "./ExecutionErrorVellumValue";
+import { ExecutionArrayVellumValue } from "./ExecutionArrayVellumValue";
+import { ExecutionFunctionCallVellumValue } from "./ExecutionFunctionCallVellumValue";
 export declare const ExecutionVellumValue: core.serialization.Schema<serializers.ExecutionVellumValue.Raw, Vellum.ExecutionVellumValue>;
 export declare namespace ExecutionVellumValue {
     type Raw = ExecutionVellumValue.String | ExecutionVellumValue.Number | ExecutionVellumValue.Json | ExecutionVellumValue.ChatHistory | ExecutionVellumValue.SearchResults | ExecutionVellumValue.Error | ExecutionVellumValue.Array | ExecutionVellumValue.FunctionCall;
-    interface String extends serializers.ExecutionStringVellumValue.Raw {
+    interface String extends ExecutionStringVellumValue.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.ExecutionNumberVellumValue.Raw {
+    interface Number extends ExecutionNumberVellumValue.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.ExecutionJsonVellumValue.Raw {
+    interface Json extends ExecutionJsonVellumValue.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.ExecutionChatHistoryVellumValue.Raw {
+    interface ChatHistory extends ExecutionChatHistoryVellumValue.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.ExecutionSearchResultsVellumValue.Raw {
+    interface SearchResults extends ExecutionSearchResultsVellumValue.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Error extends serializers.ExecutionErrorVellumValue.Raw {
+    interface Error extends ExecutionErrorVellumValue.Raw {
         type: "ERROR";
     }
-    interface Array extends serializers.ExecutionArrayVellumValue.Raw {
+    interface Array extends ExecutionArrayVellumValue.Raw {
         type: "ARRAY";
     }
-    interface FunctionCall extends serializers.ExecutionFunctionCallVellumValue.Raw {
+    interface FunctionCall extends ExecutionFunctionCallVellumValue.Raw {
         type: "FUNCTION_CALL";
     }
 }

package/serialization/types/ExecutionVellumValue.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.ExecutionVellumValue = void 0;
 const core = __importStar(require("../../core"));
+const ExecutionStringVellumValue_1 = require("./ExecutionStringVellumValue");
+const ExecutionNumberVellumValue_1 = require("./ExecutionNumberVellumValue");
+const ExecutionJsonVellumValue_1 = require("./ExecutionJsonVellumValue");
+const ExecutionChatHistoryVellumValue_1 = require("./ExecutionChatHistoryVellumValue");
+const ExecutionSearchResultsVellumValue_1 = require("./ExecutionSearchResultsVellumValue");
+const ExecutionErrorVellumValue_1 = require("./ExecutionErrorVellumValue");
+const ExecutionArrayVellumValue_1 = require("./ExecutionArrayVellumValue");
+const ExecutionFunctionCallVellumValue_1 = require("./ExecutionFunctionCallVellumValue");
 exports.ExecutionVellumValue = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionStringVellumValue; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionNumberVellumValue; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionJsonVellumValue; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionChatHistoryVellumValue; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionSearchResultsVellumValue; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionErrorVellumValue; })),
-    ARRAY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionArrayVellumValue; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionFunctionCallVellumValue; })),
+    STRING: ExecutionStringVellumValue_1.ExecutionStringVellumValue,
+    NUMBER: ExecutionNumberVellumValue_1.ExecutionNumberVellumValue,
+    JSON: ExecutionJsonVellumValue_1.ExecutionJsonVellumValue,
+    CHAT_HISTORY: ExecutionChatHistoryVellumValue_1.ExecutionChatHistoryVellumValue,
+    SEARCH_RESULTS: ExecutionSearchResultsVellumValue_1.ExecutionSearchResultsVellumValue,
+    ERROR: ExecutionErrorVellumValue_1.ExecutionErrorVellumValue,
+    ARRAY: ExecutionArrayVellumValue_1.ExecutionArrayVellumValue,
+    FUNCTION_CALL: ExecutionFunctionCallVellumValue_1.ExecutionFunctionCallVellumValue,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/FulfilledExecutePromptEvent.d.ts

@@ -4,11 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { PromptOutput } from "./PromptOutput";
+import { FulfilledPromptExecutionMeta } from "./FulfilledPromptExecutionMeta";
 export declare const FulfilledExecutePromptEvent: core.serialization.ObjectSchema<serializers.FulfilledExecutePromptEvent.Raw, Vellum.FulfilledExecutePromptEvent>;
 export declare namespace FulfilledExecutePromptEvent {
     interface Raw {
-        outputs: serializers.PromptOutput.Raw[];
+        outputs: PromptOutput.Raw[];
         execution_id: string;
-        meta?: serializers.FulfilledPromptExecutionMeta.Raw | null;
+        meta?: FulfilledPromptExecutionMeta.Raw | null;
     }
 }

package/serialization/types/FulfilledExecutePromptEvent.js

@@ -25,20 +25,13 @@ 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.FulfilledExecutePromptEvent = void 0;
 const core = __importStar(require("../../core"));
+const PromptOutput_1 = require("./PromptOutput");
+const FulfilledPromptExecutionMeta_1 = require("./FulfilledPromptExecutionMeta");
 exports.FulfilledExecutePromptEvent = core.serialization.object({
-    outputs: core.serialization.list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptOutput; }))),
+    outputs: core.serialization.list(PromptOutput_1.PromptOutput),
     executionId: core.serialization.property("execution_id", core.serialization.string()),
-    meta: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FulfilledPromptExecutionMeta; })).optional(),
+    meta: FulfilledPromptExecutionMeta_1.FulfilledPromptExecutionMeta.optional(),
 });

package/serialization/types/FulfilledExecutePromptResponse.d.ts

@@ -4,12 +4,14 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { PromptExecutionMeta } from "./PromptExecutionMeta";
+import { PromptOutput } from "./PromptOutput";
 export declare const FulfilledExecutePromptResponse: core.serialization.ObjectSchema<serializers.FulfilledExecutePromptResponse.Raw, Vellum.FulfilledExecutePromptResponse>;
 export declare namespace FulfilledExecutePromptResponse {
     interface Raw {
-        meta?: serializers.PromptExecutionMeta.Raw | null;
+        meta?: PromptExecutionMeta.Raw | null;
         raw?: Record<string, unknown> | null;
         execution_id: string;
-        outputs: serializers.PromptOutput.Raw[];
+        outputs: PromptOutput.Raw[];
     }
 }

package/serialization/types/FulfilledExecutePromptResponse.js

@@ -25,21 +25,14 @@ 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.FulfilledExecutePromptResponse = void 0;
 const core = __importStar(require("../../core"));
+const PromptExecutionMeta_1 = require("./PromptExecutionMeta");
+const PromptOutput_1 = require("./PromptOutput");
 exports.FulfilledExecutePromptResponse = core.serialization.object({
-    meta: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptExecutionMeta; })).optional(),
+    meta: PromptExecutionMeta_1.PromptExecutionMeta.optional(),
     raw: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
     executionId: core.serialization.property("execution_id", core.serialization.string()),
-    outputs: core.serialization.list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptOutput; }))),
+    outputs: core.serialization.list(PromptOutput_1.PromptOutput),
 });

package/serialization/types/FulfilledExecuteWorkflowWorkflowResultEvent.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowOutput } from "./WorkflowOutput";
 export declare const FulfilledExecuteWorkflowWorkflowResultEvent: core.serialization.ObjectSchema<serializers.FulfilledExecuteWorkflowWorkflowResultEvent.Raw, Vellum.FulfilledExecuteWorkflowWorkflowResultEvent>;
 export declare namespace FulfilledExecuteWorkflowWorkflowResultEvent {
     interface Raw {
         id: string;
         ts: string;
-        outputs: serializers.WorkflowOutput.Raw[];
+        outputs: WorkflowOutput.Raw[];
     }
 }