vellum-ai 0.0.45 → 0.1.0

package/api/resources/testSuites/client/Client.js

@@ -25,6 +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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -32,13 +41,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestSuites = void 0;
 const environments = __importStar(require("../../../../environments"));
 const core = __importStar(require("../../../../core"));
-const url_join_1 = __importDefault(require("url-join"));
 const serializers = __importStar(require("../../../../serialization"));
+const url_join_1 = __importDefault(require("url-join"));
 const errors = __importStar(require("../../../../errors"));
 class TestSuites {
-    options;
-    constructor(options) {
-        this.options = options;
+    constructor(_options) {
+        this._options = _options;
     }
     /**
      * Upserts a new test case for a test suite, keying off of the optionally provided test case id.
@@ -49,78 +57,97 @@ class TestSuites {
      * Note that a full replacement of the test case is performed, so any fields not provided will be removed
      * or overwritten with default values.
      */
-    async upsertTestSuiteTestCase(id, request) {
-        const _response = await core.fetcher({
-            url: (0, url_join_1.default)((this.options.environment ?? environments.VellumEnvironment.Production).default, `v1/test-suites/${id}/test-cases`),
-            method: "POST",
-            headers: {
-                X_API_KEY: await core.Supplier.get(this.options.apiKey),
-            },
-            contentType: "application/json",
-            body: await serializers.TestSuiteTestCaseRequest.jsonOrThrow(request, { unrecognizedObjectKeys: "strip" }),
-        });
-        if (_response.ok) {
-            return await serializers.TestSuiteTestCase.parseOrThrow(_response.body, {
-                unrecognizedObjectKeys: "passthrough",
-                allowUnrecognizedUnionMembers: true,
-                allowUnrecognizedEnumValues: true,
+    upsertTestSuiteTestCase(id, request, requestOptions) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const _response = yield core.fetcher({
+                url: (0, url_join_1.default)(((_a = (yield core.Supplier.get(this._options.environment))) !== null && _a !== void 0 ? _a : environments.VellumEnvironment.Production)
+                    .default, `v1/test-suites/${id}/test-cases`),
+                method: "POST",
+                headers: {
+                    X_API_KEY: yield core.Supplier.get(this._options.apiKey),
+                    "X-Fern-Language": "JavaScript",
+                    "X-Fern-SDK-Name": "vellum-ai",
+                    "X-Fern-SDK-Version": "v0.1.0",
+                },
+                contentType: "application/json",
+                body: yield serializers.TestSuiteTestCaseRequest.jsonOrThrow(request, { unrecognizedObjectKeys: "strip" }),
+                timeoutMs: (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1000 : undefined,
+                maxRetries: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.maxRetries,
             });
-        }
-        if (_response.error.reason === "status-code") {
-            throw new errors.VellumError({
-                statusCode: _response.error.statusCode,
-                body: _response.error.body,
-            });
-        }
-        switch (_response.error.reason) {
-            case "non-json":
-                throw new errors.VellumError({
-                    statusCode: _response.error.statusCode,
-                    body: _response.error.rawBody,
+            if (_response.ok) {
+                return yield serializers.TestSuiteTestCase.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    breadcrumbsPrefix: ["response"],
                 });
-            case "timeout":
-                throw new errors.VellumTimeoutError();
-            case "unknown":
+            }
+            if (_response.error.reason === "status-code") {
                 throw new errors.VellumError({
-                    message: _response.error.errorMessage,
+                    statusCode: _response.error.statusCode,
+                    body: _response.error.body,
                 });
-        }
+            }
+            switch (_response.error.reason) {
+                case "non-json":
+                    throw new errors.VellumError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.rawBody,
+                    });
+                case "timeout":
+                    throw new errors.VellumTimeoutError();
+                case "unknown":
+                    throw new errors.VellumError({
+                        message: _response.error.errorMessage,
+                    });
+            }
+        });
     }
     /**
      * Deletes an existing test case for a test suite, keying off of the test case id.
      *
      */
-    async deleteTestSuiteTestCase(id, testCaseId) {
-        const _response = await core.fetcher({
-            url: (0, url_join_1.default)((this.options.environment ?? environments.VellumEnvironment.Production).default, `v1/test-suites/${id}/test-cases/${testCaseId}`),
-            method: "DELETE",
-            headers: {
-                X_API_KEY: await core.Supplier.get(this.options.apiKey),
-            },
-            contentType: "application/json",
-        });
-        if (_response.ok) {
-            return;
-        }
-        if (_response.error.reason === "status-code") {
-            throw new errors.VellumError({
-                statusCode: _response.error.statusCode,
-                body: _response.error.body,
+    deleteTestSuiteTestCase(id, testCaseId, requestOptions) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const _response = yield core.fetcher({
+                url: (0, url_join_1.default)(((_a = (yield core.Supplier.get(this._options.environment))) !== null && _a !== void 0 ? _a : environments.VellumEnvironment.Production)
+                    .default, `v1/test-suites/${id}/test-cases/${testCaseId}`),
+                method: "DELETE",
+                headers: {
+                    X_API_KEY: yield core.Supplier.get(this._options.apiKey),
+                    "X-Fern-Language": "JavaScript",
+                    "X-Fern-SDK-Name": "vellum-ai",
+                    "X-Fern-SDK-Version": "v0.1.0",
+                },
+                contentType: "application/json",
+                timeoutMs: (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1000 : undefined,
+                maxRetries: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.maxRetries,
             });
-        }
-        switch (_response.error.reason) {
-            case "non-json":
+            if (_response.ok) {
+                return;
+            }
+            if (_response.error.reason === "status-code") {
                 throw new errors.VellumError({
                     statusCode: _response.error.statusCode,
-                    body: _response.error.rawBody,
+                    body: _response.error.body,
                 });
-            case "timeout":
-                throw new errors.VellumTimeoutError();
-            case "unknown":
-                throw new errors.VellumError({
-                    message: _response.error.errorMessage,
-                });
-        }
+            }
+            switch (_response.error.reason) {
+                case "non-json":
+                    throw new errors.VellumError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.rawBody,
+                    });
+                case "timeout":
+                    throw new errors.VellumTimeoutError();
+                case "unknown":
+                    throw new errors.VellumError({
+                        message: _response.error.errorMessage,
+                    });
+            }
+        });
     }
 }
 exports.TestSuites = TestSuites;

package/core/fetcher/Fetcher.d.ts

@@ -1,18 +1,20 @@
-import URLSearchParams from "@ungap/url-search-params";
 import { AxiosAdapter } from "axios";
 import { APIResponse } from "./APIResponse";
-export declare type FetchFunction = (args: Fetcher.Args) => Promise<APIResponse<unknown, Fetcher.Error>>;
+export declare type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
 export declare namespace Fetcher {
     interface Args {
         url: string;
         method: string;
         contentType?: string;
         headers?: Record<string, string | undefined>;
-        queryParameters?: URLSearchParams;
+        queryParameters?: Record<string, string | string[]>;
         body?: unknown;
         timeoutMs?: number;
+        maxRetries?: number;
         withCredentials?: boolean;
+        responseType?: "json" | "blob";
         adapter?: AxiosAdapter;
+        onUploadProgress?: (event: ProgressEvent) => void;
     }
     type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
     interface FailedStatusCodeError {

package/core/fetcher/Fetcher.js

@@ -1,87 +1,129 @@
 "use strict";
+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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetcher = void 0;
 const axios_1 = __importDefault(require("axios"));
-const fetcher = async (args) => {
-    const headers = {};
-    if (args.body !== undefined && args.contentType != null) {
-        headers["Content-Type"] = args.contentType;
-    }
-    if (args.headers != null) {
-        for (const [key, value] of Object.entries(args.headers)) {
-            if (value != null) {
-                headers[key] = value;
+const qs_1 = __importDefault(require("qs"));
+const INITIAL_RETRY_DELAY = 1;
+const MAX_RETRY_DELAY = 60;
+const DEFAULT_MAX_RETRIES = 2;
+function fetcherImpl(args) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const headers = {};
+        if (args.body !== undefined && args.contentType != null) {
+            headers["Content-Type"] = args.contentType;
+        }
+        if (args.headers != null) {
+            for (const [key, value] of Object.entries(args.headers)) {
+                if (value != null) {
+                    headers[key] = value;
+                }
             }
         }
-    }
-    try {
-        const response = await (0, axios_1.default)({
-            url: args.url,
-            params: args.queryParameters,
-            method: args.method,
-            headers,
-            data: args.body,
-            validateStatus: () => true,
-            transformResponse: (response) => response,
-            timeout: args.timeoutMs,
-            transitional: {
-                clarifyTimeoutError: true,
-            },
-            withCredentials: args.withCredentials,
-            adapter: args.adapter,
+        const makeRequest = () => __awaiter(this, void 0, void 0, function* () {
+            var _d;
+            return yield (0, axios_1.default)({
+                url: args.url,
+                params: args.queryParameters,
+                paramsSerializer: (params) => {
+                    return qs_1.default.stringify(params, { arrayFormat: "repeat" });
+                },
+                method: args.method,
+                headers,
+                data: args.body,
+                validateStatus: () => true,
+                transformResponse: (response) => response,
+                timeout: args.timeoutMs,
+                transitional: {
+                    clarifyTimeoutError: true,
+                },
+                withCredentials: args.withCredentials,
+                adapter: args.adapter,
+                onUploadProgress: args.onUploadProgress,
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+                responseType: (_d = args.responseType) !== null && _d !== void 0 ? _d : "json",
+            });
         });
-        let body;
-        if (response.data != null && response.data.length > 0) {
-            try {
-                body = JSON.parse(response.data) ?? undefined;
+        try {
+            let response = yield makeRequest();
+            for (let i = 0; i < ((_a = args.maxRetries) !== null && _a !== void 0 ? _a : DEFAULT_MAX_RETRIES); ++i) {
+                if (response.status === 408 ||
+                    response.status === 409 ||
+                    response.status === 429 ||
+                    response.status >= 500) {
+                    const delay = Math.min(INITIAL_RETRY_DELAY * Math.pow(i, 2), MAX_RETRY_DELAY);
+                    response = yield new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                else {
+                    break;
+                }
             }
-            catch {
+            let body;
+            if (args.responseType === "blob") {
+                body = response.data;
+            }
+            else if (response.data != null && response.data.length > 0) {
+                try {
+                    body = (_b = JSON.parse(response.data)) !== null && _b !== void 0 ? _b : undefined;
+                }
+                catch (_c) {
+                    return {
+                        ok: false,
+                        error: {
+                            reason: "non-json",
+                            statusCode: response.status,
+                            rawBody: response.data,
+                        },
+                    };
+                }
+            }
+            if (response.status >= 200 && response.status < 400) {
+                return {
+                    ok: true,
+                    body: body,
+                };
+            }
+            else {
                 return {
                     ok: false,
                     error: {
-                        reason: "non-json",
+                        reason: "status-code",
                         statusCode: response.status,
-                        rawBody: response.data,
+                        body,
                     },
                 };
             }
         }
-        if (response.status >= 200 && response.status < 300) {
-            return {
-                ok: true,
-                body,
-            };
-        }
-        else {
-            return {
-                ok: false,
-                error: {
-                    reason: "status-code",
-                    statusCode: response.status,
-                    body,
-                },
-            };
-        }
-    }
-    catch (error) {
-        if (error.code === "ETIMEDOUT") {
+        catch (error) {
+            if (error.code === "ETIMEDOUT") {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "timeout",
+                    },
+                };
+            }
             return {
                 ok: false,
                 error: {
-                    reason: "timeout",
+                    reason: "unknown",
+                    errorMessage: error.message,
                 },
             };
         }
-        return {
-            ok: false,
-            error: {
-                reason: "unknown",
-                errorMessage: error.message,
-            },
-        };
-    }
-};
-exports.fetcher = fetcher;
+    });
+}
+exports.fetcher = fetcherImpl;

package/core/fetcher/Supplier.js

@@ -1,13 +1,22 @@
 "use strict";
+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.Supplier = void 0;
 exports.Supplier = {
-    get: async (supplier) => {
+    get: (supplier) => __awaiter(void 0, void 0, void 0, function* () {
         if (typeof supplier === "function") {
             return supplier();
         }
         else {
             return supplier;
         }
-    },
+    }),
 };

package/core/fetcher/index.d.ts

@@ -1,3 +1,4 @@
-export { type APIResponse } from "./APIResponse";
-export { fetcher, type Fetcher, type FetchFunction } from "./Fetcher";
+export type { APIResponse } from "./APIResponse";
+export { fetcher } from "./Fetcher";
+export type { Fetcher, FetchFunction } from "./Fetcher";
 export { Supplier } from "./Supplier";

package/core/form-data-utils/getFormDataContentLength.d.ts

@@ -1,2 +1,2 @@
-import FormData from "form-data";
+import { default as FormData } from "form-data";
 export declare function getFormDataContentLength(formData: FormData): Promise<number>;

package/core/form-data-utils/getFormDataContentLength.js

@@ -1,15 +1,26 @@
 "use strict";
+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.getFormDataContentLength = void 0;
-async function getFormDataContentLength(formData) {
-    return new Promise((resolve, reject) => {
-        formData.getLength((err, length) => {
-            if (err != null) {
-                reject(err);
-            }
-            else {
-                resolve(length);
-            }
+function getFormDataContentLength(formData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            formData.getLength((err, length) => {
+                if (err != null) {
+                    reject(err);
+                }
+                else {
+                    resolve(length);
+                }
+            });
         });
     });
 }

package/core/index.d.ts

@@ -1,5 +1,4 @@
-export * as serialization from "./schemas";
 export * from "./fetcher";
 export * from "./streaming-fetcher";
-export * from "./callback-queue";
 export * from "./form-data-utils";
+export * as serialization from "./schemas";

package/core/index.js

@@ -15,6 +15,9 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -22,13 +25,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serialization = void 0;
-exports.serialization = __importStar(require("./schemas"));
 __exportStar(require("./fetcher"), exports);
 __exportStar(require("./streaming-fetcher"), exports);
-__exportStar(require("./callback-queue"), exports);
 __exportStar(require("./form-data-utils"), exports);
+exports.serialization = __importStar(require("./schemas"));

package/core/schemas/Schema.d.ts

@@ -13,6 +13,7 @@ export declare const SchemaType: {
     readonly ENUM: "enum";
     readonly LIST: "list";
     readonly STRING_LITERAL: "stringLiteral";
+    readonly BOOLEAN_LITERAL: "booleanLiteral";
     readonly OBJECT: "object";
     readonly ANY: "any";
     readonly BOOLEAN: "boolean";
@@ -59,4 +60,22 @@ export interface SchemaOptions {
      * @default false
      */
     allowUnrecognizedEnumValues?: boolean;
+    /**
+     * whether to allow data that doesn't conform to the schema.
+     * invalid data is passed through without transformation.
+     *
+     * when this is enabled, .parse() and .json() will always
+     * return `ok: true`. `.parseOrThrow()` and `.jsonOrThrow()`
+     * will never fail.
+     *
+     * @default false
+     */
+    skipValidation?: boolean;
+    /**
+     * each validation failure contains a "path" property, which is
+     * the breadcrumbs to the offending node in the JSON. you can supply
+     * a prefix that is prepended to all the errors' paths. this can be
+     * helpful for zurg's internal debug logging.
+     */
+    breadcrumbsPrefix?: string[];
 }

package/core/schemas/Schema.js

@@ -6,6 +6,7 @@ exports.SchemaType = {
     ENUM: "enum",
     LIST: "list",
     STRING_LITERAL: "stringLiteral",
+    BOOLEAN_LITERAL: "booleanLiteral",
     OBJECT: "object",
     ANY: "any",
     BOOLEAN: "boolean",

package/core/schemas/builders/date/date.js

@@ -2,31 +2,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.date = void 0;
 const Schema_1 = require("../../Schema");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
 // https://stackoverflow.com/questions/12756159/regex-and-iso8601-formatted-datetime
 const ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
 function date() {
     const baseSchema = {
-        parse: (raw) => {
-            if (typeof raw === "string" && ISO_8601_REGEX.test(raw)) {
+        parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+            if (typeof raw !== "string") {
                 return {
-                    ok: true,
-                    value: new Date(raw),
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "string"),
+                        },
+                    ],
                 };
             }
-            else {
+            if (!ISO_8601_REGEX.test(raw)) {
                 return {
                     ok: false,
                     errors: [
                         {
-                            path: [],
-                            message: "Not an ISO 8601 date string",
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "ISO 8601 date string"),
                         },
                     ],
                 };
             }
+            return {
+                ok: true,
+                value: new Date(raw),
+            };
         },
-        json: (date) => {
+        json: (date, { breadcrumbsPrefix = [] } = {}) => {
             if (date instanceof Date) {
                 return {
                     ok: true,
@@ -38,8 +49,8 @@ function date() {
                     ok: false,
                     errors: [
                         {
-                            path: [],
-                            message: "Not a Date object",
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(date, "Date object"),
                         },
                     ],
                 };
@@ -47,9 +58,6 @@ function date() {
         },
         getType: () => Schema_1.SchemaType.DATE,
     };
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
 exports.date = date;