langsmith 0.5.15 → 0.5.17

package/dist/utils/chalk/source/vendor/ansi-styles/index.cjs

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorNames = exports.backgroundColorNames = exports.foregroundColorNames = exports.modifierNames = void 0;
+/* eslint-disable */
+// @ts-nocheck
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles = {
+    modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29],
+    },
+    color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39], // Alias of `blackBright`
+        grey: [90, 39], // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39],
+    },
+    bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49], // Alias of `bgBlackBright`
+        bgGrey: [100, 49], // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49],
+    },
+};
+exports.modifierNames = Object.keys(styles.modifier);
+exports.foregroundColorNames = Object.keys(styles.color);
+exports.backgroundColorNames = Object.keys(styles.bgColor);
+exports.colorNames = [...exports.foregroundColorNames, ...exports.backgroundColorNames];
+function assembleStyles() {
+    const codes = new Map();
+    for (const [groupName, group] of Object.entries(styles)) {
+        for (const [styleName, style] of Object.entries(group)) {
+            styles[styleName] = {
+                open: `\u001B[${style[0]}m`,
+                close: `\u001B[${style[1]}m`,
+            };
+            group[styleName] = styles[styleName];
+            codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+            value: group,
+            enumerable: false,
+        });
+    }
+    Object.defineProperty(styles, 'codes', {
+        value: codes,
+        enumerable: false,
+    });
+    styles.color.close = '\u001B[39m';
+    styles.bgColor.close = '\u001B[49m';
+    styles.color.ansi = wrapAnsi16();
+    styles.color.ansi256 = wrapAnsi256();
+    styles.color.ansi16m = wrapAnsi16m();
+    styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+    styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+    styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+    // From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+    Object.defineProperties(styles, {
+        rgbToAnsi256: {
+            value(red, green, blue) {
+                // We use the extended greyscale palette here, with the exception of
+                // black and white. normal palette only has 4 greyscale shades.
+                if (red === green && green === blue) {
+                    if (red < 8) {
+                        return 16;
+                    }
+                    if (red > 248) {
+                        return 231;
+                    }
+                    return Math.round(((red - 8) / 247) * 24) + 232;
+                }
+                return 16
+                    + (36 * Math.round(red / 255 * 5))
+                    + (6 * Math.round(green / 255 * 5))
+                    + Math.round(blue / 255 * 5);
+            },
+            enumerable: false,
+        },
+        hexToRgb: {
+            value(hex) {
+                const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+                if (!matches) {
+                    return [0, 0, 0];
+                }
+                let [colorString] = matches;
+                if (colorString.length === 3) {
+                    colorString = [...colorString].map(character => character + character).join('');
+                }
+                const integer = Number.parseInt(colorString, 16);
+                return [
+                    /* eslint-disable no-bitwise */
+                    (integer >> 16) & 0xFF,
+                    (integer >> 8) & 0xFF,
+                    integer & 0xFF,
+                    /* eslint-enable no-bitwise */
+                ];
+            },
+            enumerable: false,
+        },
+        hexToAnsi256: {
+            value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+            enumerable: false,
+        },
+        ansi256ToAnsi: {
+            value(code) {
+                if (code < 8) {
+                    return 30 + code;
+                }
+                if (code < 16) {
+                    return 90 + (code - 8);
+                }
+                let red;
+                let green;
+                let blue;
+                if (code >= 232) {
+                    red = (((code - 232) * 10) + 8) / 255;
+                    green = red;
+                    blue = red;
+                }
+                else {
+                    code -= 16;
+                    const remainder = code % 36;
+                    red = Math.floor(code / 36) / 5;
+                    green = Math.floor(remainder / 6) / 5;
+                    blue = (remainder % 6) / 5;
+                }
+                const value = Math.max(red, green, blue) * 2;
+                if (value === 0) {
+                    return 30;
+                }
+                // eslint-disable-next-line no-bitwise
+                let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
+                if (value === 2) {
+                    result += 60;
+                }
+                return result;
+            },
+            enumerable: false,
+        },
+        rgbToAnsi: {
+            value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+            enumerable: false,
+        },
+        hexToAnsi: {
+            value: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+            enumerable: false,
+        },
+    });
+    return styles;
+}
+const ansiStyles = assembleStyles();
+exports.default = ansiStyles;

package/dist/utils/chalk/source/vendor/ansi-styles/index.d.ts

@@ -0,0 +1,58 @@
+export declare const modifierNames: string[];
+export declare const foregroundColorNames: string[];
+export declare const backgroundColorNames: string[];
+export declare const colorNames: string[];
+declare const ansiStyles: {
+    modifier: {
+        reset: number[];
+        bold: number[];
+        dim: number[];
+        italic: number[];
+        underline: number[];
+        overline: number[];
+        inverse: number[];
+        hidden: number[];
+        strikethrough: number[];
+    };
+    color: {
+        black: number[];
+        red: number[];
+        green: number[];
+        yellow: number[];
+        blue: number[];
+        magenta: number[];
+        cyan: number[];
+        white: number[];
+        blackBright: number[];
+        gray: number[];
+        grey: number[];
+        redBright: number[];
+        greenBright: number[];
+        yellowBright: number[];
+        blueBright: number[];
+        magentaBright: number[];
+        cyanBright: number[];
+        whiteBright: number[];
+    };
+    bgColor: {
+        bgBlack: number[];
+        bgRed: number[];
+        bgGreen: number[];
+        bgYellow: number[];
+        bgBlue: number[];
+        bgMagenta: number[];
+        bgCyan: number[];
+        bgWhite: number[];
+        bgBlackBright: number[];
+        bgGray: number[];
+        bgGrey: number[];
+        bgRedBright: number[];
+        bgGreenBright: number[];
+        bgYellowBright: number[];
+        bgBlueBright: number[];
+        bgMagentaBright: number[];
+        bgCyanBright: number[];
+        bgWhiteBright: number[];
+    };
+};
+export default ansiStyles;

package/dist/utils/chalk/source/vendor/ansi-styles/index.js

@@ -0,0 +1,190 @@
+/* eslint-disable */
+// @ts-nocheck
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles = {
+    modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29],
+    },
+    color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39], // Alias of `blackBright`
+        grey: [90, 39], // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39],
+    },
+    bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49], // Alias of `bgBlackBright`
+        bgGrey: [100, 49], // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49],
+    },
+};
+export const modifierNames = Object.keys(styles.modifier);
+export const foregroundColorNames = Object.keys(styles.color);
+export const backgroundColorNames = Object.keys(styles.bgColor);
+export const colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+    const codes = new Map();
+    for (const [groupName, group] of Object.entries(styles)) {
+        for (const [styleName, style] of Object.entries(group)) {
+            styles[styleName] = {
+                open: `\u001B[${style[0]}m`,
+                close: `\u001B[${style[1]}m`,
+            };
+            group[styleName] = styles[styleName];
+            codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+            value: group,
+            enumerable: false,
+        });
+    }
+    Object.defineProperty(styles, 'codes', {
+        value: codes,
+        enumerable: false,
+    });
+    styles.color.close = '\u001B[39m';
+    styles.bgColor.close = '\u001B[49m';
+    styles.color.ansi = wrapAnsi16();
+    styles.color.ansi256 = wrapAnsi256();
+    styles.color.ansi16m = wrapAnsi16m();
+    styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+    styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+    styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+    // From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+    Object.defineProperties(styles, {
+        rgbToAnsi256: {
+            value(red, green, blue) {
+                // We use the extended greyscale palette here, with the exception of
+                // black and white. normal palette only has 4 greyscale shades.
+                if (red === green && green === blue) {
+                    if (red < 8) {
+                        return 16;
+                    }
+                    if (red > 248) {
+                        return 231;
+                    }
+                    return Math.round(((red - 8) / 247) * 24) + 232;
+                }
+                return 16
+                    + (36 * Math.round(red / 255 * 5))
+                    + (6 * Math.round(green / 255 * 5))
+                    + Math.round(blue / 255 * 5);
+            },
+            enumerable: false,
+        },
+        hexToRgb: {
+            value(hex) {
+                const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+                if (!matches) {
+                    return [0, 0, 0];
+                }
+                let [colorString] = matches;
+                if (colorString.length === 3) {
+                    colorString = [...colorString].map(character => character + character).join('');
+                }
+                const integer = Number.parseInt(colorString, 16);
+                return [
+                    /* eslint-disable no-bitwise */
+                    (integer >> 16) & 0xFF,
+                    (integer >> 8) & 0xFF,
+                    integer & 0xFF,
+                    /* eslint-enable no-bitwise */
+                ];
+            },
+            enumerable: false,
+        },
+        hexToAnsi256: {
+            value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+            enumerable: false,
+        },
+        ansi256ToAnsi: {
+            value(code) {
+                if (code < 8) {
+                    return 30 + code;
+                }
+                if (code < 16) {
+                    return 90 + (code - 8);
+                }
+                let red;
+                let green;
+                let blue;
+                if (code >= 232) {
+                    red = (((code - 232) * 10) + 8) / 255;
+                    green = red;
+                    blue = red;
+                }
+                else {
+                    code -= 16;
+                    const remainder = code % 36;
+                    red = Math.floor(code / 36) / 5;
+                    green = Math.floor(remainder / 6) / 5;
+                    blue = (remainder % 6) / 5;
+                }
+                const value = Math.max(red, green, blue) * 2;
+                if (value === 0) {
+                    return 30;
+                }
+                // eslint-disable-next-line no-bitwise
+                let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
+                if (value === 2) {
+                    result += 60;
+                }
+                return result;
+            },
+            enumerable: false,
+        },
+        rgbToAnsi: {
+            value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+            enumerable: false,
+        },
+        hexToAnsi: {
+            value: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+            enumerable: false,
+        },
+    });
+    return styles;
+}
+const ansiStyles = assembleStyles();
+export default ansiStyles;

package/dist/utils/chalk/source/vendor/supports-color/browser.cjs

@@ -0,0 +1,31 @@
+"use strict";
+/* eslint-disable */
+// @ts-nocheck
+/* eslint-env browser */
+Object.defineProperty(exports, "__esModule", { value: true });
+const level = (() => {
+    if (!('navigator' in globalThis)) {
+        return 0;
+    }
+    if (globalThis.navigator.userAgentData) {
+        const brand = navigator.userAgentData.brands.find(({ brand }) => brand === 'Chromium');
+        if (brand && brand.version > 93) {
+            return 3;
+        }
+    }
+    if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) {
+        return 1;
+    }
+    return 0;
+})();
+const colorSupport = level !== 0 && {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3,
+};
+const supportsColor = {
+    stdout: colorSupport,
+    stderr: colorSupport,
+};
+exports.default = supportsColor;

package/dist/utils/chalk/source/vendor/supports-color/browser.d.ts

@@ -0,0 +1,15 @@
+declare const supportsColor: {
+    stdout: false | {
+        level: number;
+        hasBasic: boolean;
+        has256: boolean;
+        has16m: boolean;
+    };
+    stderr: false | {
+        level: number;
+        hasBasic: boolean;
+        has256: boolean;
+        has16m: boolean;
+    };
+};
+export default supportsColor;

package/dist/utils/chalk/source/vendor/supports-color/browser.js

@@ -0,0 +1,29 @@
+/* eslint-disable */
+// @ts-nocheck
+/* eslint-env browser */
+const level = (() => {
+    if (!('navigator' in globalThis)) {
+        return 0;
+    }
+    if (globalThis.navigator.userAgentData) {
+        const brand = navigator.userAgentData.brands.find(({ brand }) => brand === 'Chromium');
+        if (brand && brand.version > 93) {
+            return 3;
+        }
+    }
+    if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) {
+        return 1;
+    }
+    return 0;
+})();
+const colorSupport = level !== 0 && {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3,
+};
+const supportsColor = {
+    stdout: colorSupport,
+    stderr: colorSupport,
+};
+export default supportsColor;

package/dist/utils/chalk/source/vendor/supports-color/index.cjs

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSupportsColor = createSupportsColor;
+/* eslint-disable */
+// @ts-nocheck
+const node_process_1 = __importDefault(require("node:process"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_tty_1 = __importDefault(require("node:tty"));
+// From: https://github.com/sindresorhus/has-flag/blob/main/index.js
+/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : node_process_1.default.argv) {
+    const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf('--');
+    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = node_process_1.default;
+let flagForceColor;
+if (hasFlag('no-color')
+    || hasFlag('no-colors')
+    || hasFlag('color=false')
+    || hasFlag('color=never')) {
+    flagForceColor = 0;
+}
+else if (hasFlag('color')
+    || hasFlag('colors')
+    || hasFlag('color=true')
+    || hasFlag('color=always')) {
+    flagForceColor = 1;
+}
+function envForceColor() {
+    if ('FORCE_COLOR' in env) {
+        if (env.FORCE_COLOR === 'true') {
+            return 1;
+        }
+        if (env.FORCE_COLOR === 'false') {
+            return 0;
+        }
+        return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    }
+}
+function translateLevel(level) {
+    if (level === 0) {
+        return false;
+    }
+    return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3,
+    };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+    const noFlagForceColor = envForceColor();
+    if (noFlagForceColor !== undefined) {
+        flagForceColor = noFlagForceColor;
+    }
+    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+    if (forceColor === 0) {
+        return 0;
+    }
+    if (sniffFlags) {
+        if (hasFlag('color=16m')
+            || hasFlag('color=full')
+            || hasFlag('color=truecolor')) {
+            return 3;
+        }
+        if (hasFlag('color=256')) {
+            return 2;
+        }
+    }
+    // Check for Azure DevOps pipelines.
+    // Has to be above the `!streamIsTTY` check.
+    if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
+        return 1;
+    }
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+        return 0;
+    }
+    const min = forceColor || 0;
+    if (env.TERM === 'dumb') {
+        return min;
+    }
+    if (node_process_1.default.platform === 'win32') {
+        // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+        // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+        const osRelease = node_os_1.default.release().split('.');
+        if (Number(osRelease[0]) >= 10
+            && Number(osRelease[2]) >= 10_586) {
+            return Number(osRelease[2]) >= 14_931 ? 3 : 2;
+        }
+        return 1;
+    }
+    if ('CI' in env) {
+        if (['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some(key => key in env)) {
+            return 3;
+        }
+        if (['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+            return 1;
+        }
+        return min;
+    }
+    if ('TEAMCITY_VERSION' in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    }
+    if (env.COLORTERM === 'truecolor') {
+        return 3;
+    }
+    if (env.TERM === 'xterm-kitty') {
+        return 3;
+    }
+    if (env.TERM === 'xterm-ghostty') {
+        return 3;
+    }
+    if (env.TERM === 'wezterm') {
+        return 3;
+    }
+    if ('TERM_PROGRAM' in env) {
+        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+        switch (env.TERM_PROGRAM) {
+            case 'iTerm.app': {
+                return version >= 3 ? 3 : 2;
+            }
+            case 'Apple_Terminal': {
+                return 2;
+            }
+            // No default
+        }
+    }
+    if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+    }
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+    }
+    if ('COLORTERM' in env) {
+        return 1;
+    }
+    return min;
+}
+function createSupportsColor(stream, options = {}) {
+    const level = _supportsColor(stream, {
+        streamIsTTY: stream && stream.isTTY,
+        ...options,
+    });
+    return translateLevel(level);
+}
+const supportsColor = {
+    stdout: createSupportsColor({ isTTY: node_tty_1.default.isatty(1) }),
+    stderr: createSupportsColor({ isTTY: node_tty_1.default.isatty(2) }),
+};
+exports.default = supportsColor;

package/dist/utils/chalk/source/vendor/supports-color/index.d.ts

@@ -0,0 +1,21 @@
+export declare function createSupportsColor(stream: any, options?: {}): false | {
+    level: any;
+    hasBasic: boolean;
+    has256: boolean;
+    has16m: boolean;
+};
+declare const supportsColor: {
+    stdout: boolean | {
+        level: any;
+        hasBasic: boolean;
+        has256: boolean;
+        has16m: boolean;
+    };
+    stderr: boolean | {
+        level: any;
+        hasBasic: boolean;
+        has256: boolean;
+        has16m: boolean;
+    };
+};
+export default supportsColor;