langsmith 0.0.1-0

package/dist/schemas.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schemas.d.ts

@@ -0,0 +1,117 @@
+export interface TracerSession {
+    tenant_id: string;
+    id: string;
+    start_time: number;
+    name?: string;
+    mode?: string;
+}
+export interface TracerSessionResult extends TracerSession {
+    run_count?: number;
+    latency_p50?: number;
+    latency_p99?: number;
+    total_tokens?: number;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    last_run_start_time?: number;
+    feedback_stats?: Record<string, unknown>;
+    reference_dataset_ids?: string[];
+    run_facets?: KVMap[];
+}
+export type KVMap = Record<string, any>;
+export type RunType = "llm" | "chain" | "tool";
+export type ScoreType = number | boolean | null;
+export type ValueType = number | boolean | string | object | null;
+export interface BaseExample {
+    dataset_id: string;
+    inputs: KVMap;
+    outputs?: KVMap;
+}
+export interface BaseRun {
+    id?: string;
+    name: string;
+    serialized?: object;
+    inputs: KVMap;
+    run_type: RunType;
+    start_time?: number;
+    end_time?: number;
+    extra?: KVMap;
+    error?: string;
+    execution_order?: number;
+    outputs?: KVMap;
+    reference_example_id?: string;
+    parent_run_id?: string;
+    events?: KVMap[];
+    tags?: string[];
+}
+export interface Run extends BaseRun {
+    id: string;
+    session_id?: string;
+    execution_order: number;
+    start_time: number;
+    child_run_ids?: string[];
+    feedback_stats?: KVMap;
+    child_runs?: Run[];
+}
+export interface RunCreate extends BaseRun {
+    child_runs?: this[];
+    session_name?: string;
+}
+export interface RunUpdate {
+    end_time?: number;
+    error?: string;
+    outputs?: KVMap;
+    parent_run_id?: string;
+    reference_example_id?: string;
+}
+export interface ExampleCreate extends BaseExample {
+    id?: string;
+    created_at: string;
+}
+export interface Example extends BaseExample {
+    id: string;
+    created_at: string;
+    modified_at: string;
+    runs: Run[];
+}
+export interface ExampleUpdate {
+    dataset_id?: string;
+    inputs?: KVMap;
+    outputs?: KVMap;
+}
+export interface BaseDataset {
+    name: string;
+    description: string;
+    tenant_id: string;
+}
+export interface Dataset extends BaseDataset {
+    id: string;
+    created_at: string;
+    modified_at: string;
+}
+export interface FeedbackSourceBase {
+    type: string;
+    metadata?: KVMap;
+}
+export interface APIFeedbackSource extends FeedbackSourceBase {
+    type: "api";
+}
+export interface ModelFeedbackSource extends FeedbackSourceBase {
+    type: "model";
+}
+export interface FeedbackBase {
+    created_at: string;
+    modified_at: string;
+    run_id: string;
+    key: string;
+    score: ScoreType;
+    value: ValueType;
+    comment: string | null;
+    correction: string | object | null;
+    feedback_source: APIFeedbackSource | ModelFeedbackSource | KVMap | null;
+}
+export interface FeedbackCreate extends FeedbackBase {
+    id: string;
+}
+export interface Feedback extends FeedbackBase {
+    id: string;
+}

package/dist/schemas.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/async_caller.cjs

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncCaller = void 0;
+const p_retry_1 = __importDefault(require("p-retry"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const STATUS_NO_RETRY = [
+    400,
+    401,
+    403,
+    404,
+    405,
+    406,
+    407,
+    408,
+    409, // Conflict
+];
+/**
+ * A class that can be used to make async calls with concurrency and retry logic.
+ *
+ * This is useful for making calls to any kind of "expensive" external resource,
+ * be it because it's rate-limited, subject to network issues, etc.
+ *
+ * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
+ * to `Infinity`. This means that by default, all calls will be made in parallel.
+ *
+ * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
+ * means that by default, each call will be retried up to 6 times, with an
+ * exponential backoff between each attempt.
+ */
+class AsyncCaller {
+    constructor(params) {
+        Object.defineProperty(this, "maxConcurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxRetries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxConcurrency = params.maxConcurrency ?? Infinity;
+        this.maxRetries = params.maxRetries ?? 6;
+        const PQueue = "default" in p_queue_1.default ? p_queue_1.default.default : p_queue_1.default;
+        this.queue = new PQueue({ concurrency: this.maxConcurrency });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    call(callable, ...args) {
+        return this.queue.add(() => (0, p_retry_1.default)(() => callable(...args).catch((error) => {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (error instanceof Error) {
+                throw error;
+            }
+            else {
+                throw new Error(error);
+            }
+        }), {
+            onFailedAttempt(error) {
+                if (error.message.startsWith("Cancel") ||
+                    error.message.startsWith("TimeoutError") ||
+                    error.message.startsWith("AbortError")) {
+                    throw error;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (error?.code === "ECONNABORTED") {
+                    throw error;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const status = error?.response?.status;
+                if (status && STATUS_NO_RETRY.includes(+status)) {
+                    throw error;
+                }
+            },
+            retries: this.maxRetries,
+            randomize: true,
+            // If needed we can change some of the defaults here,
+            // but they're quite sensible.
+        }), { throwOnTimeout: true });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    callWithOptions(options, callable, ...args) {
+        // Note this doesn't cancel the underlying request,
+        // when available prefer to use the signal option of the underlying call
+        if (options.signal) {
+            return Promise.race([
+                this.call(callable, ...args),
+                new Promise((_, reject) => {
+                    options.signal?.addEventListener("abort", () => {
+                        reject(new Error("AbortError"));
+                    });
+                }),
+            ]);
+        }
+        return this.call(callable, ...args);
+    }
+    fetch(...args) {
+        return this.call(() => fetch(...args).then((res) => (res.ok ? res : Promise.reject(res))));
+    }
+}
+exports.AsyncCaller = AsyncCaller;

package/dist/utils/async_caller.d.ts

@@ -0,0 +1,37 @@
+export interface AsyncCallerParams {
+    /**
+     * The maximum number of concurrent calls that can be made.
+     * Defaults to `Infinity`, which means no limit.
+     */
+    maxConcurrency?: number;
+    /**
+     * The maximum number of retries that can be made for a single call,
+     * with an exponential backoff between each attempt. Defaults to 6.
+     */
+    maxRetries?: number;
+}
+export interface AsyncCallerCallOptions {
+    signal?: AbortSignal;
+}
+/**
+ * A class that can be used to make async calls with concurrency and retry logic.
+ *
+ * This is useful for making calls to any kind of "expensive" external resource,
+ * be it because it's rate-limited, subject to network issues, etc.
+ *
+ * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
+ * to `Infinity`. This means that by default, all calls will be made in parallel.
+ *
+ * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
+ * means that by default, each call will be retried up to 6 times, with an
+ * exponential backoff between each attempt.
+ */
+export declare class AsyncCaller {
+    protected maxConcurrency: AsyncCallerParams["maxConcurrency"];
+    protected maxRetries: AsyncCallerParams["maxRetries"];
+    private queue;
+    constructor(params: AsyncCallerParams);
+    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;
+}

package/dist/utils/async_caller.js

@@ -0,0 +1,104 @@
+import pRetry from "p-retry";
+import PQueueMod from "p-queue";
+const STATUS_NO_RETRY = [
+    400,
+    401,
+    403,
+    404,
+    405,
+    406,
+    407,
+    408,
+    409, // Conflict
+];
+/**
+ * A class that can be used to make async calls with concurrency and retry logic.
+ *
+ * This is useful for making calls to any kind of "expensive" external resource,
+ * be it because it's rate-limited, subject to network issues, etc.
+ *
+ * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
+ * to `Infinity`. This means that by default, all calls will be made in parallel.
+ *
+ * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
+ * means that by default, each call will be retried up to 6 times, with an
+ * exponential backoff between each attempt.
+ */
+export class AsyncCaller {
+    constructor(params) {
+        Object.defineProperty(this, "maxConcurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxRetries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxConcurrency = params.maxConcurrency ?? Infinity;
+        this.maxRetries = params.maxRetries ?? 6;
+        const PQueue = "default" in PQueueMod ? PQueueMod.default : PQueueMod;
+        this.queue = new PQueue({ concurrency: this.maxConcurrency });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    call(callable, ...args) {
+        return this.queue.add(() => pRetry(() => callable(...args).catch((error) => {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (error instanceof Error) {
+                throw error;
+            }
+            else {
+                throw new Error(error);
+            }
+        }), {
+            onFailedAttempt(error) {
+                if (error.message.startsWith("Cancel") ||
+                    error.message.startsWith("TimeoutError") ||
+                    error.message.startsWith("AbortError")) {
+                    throw error;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (error?.code === "ECONNABORTED") {
+                    throw error;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const status = error?.response?.status;
+                if (status && STATUS_NO_RETRY.includes(+status)) {
+                    throw error;
+                }
+            },
+            retries: this.maxRetries,
+            randomize: true,
+            // If needed we can change some of the defaults here,
+            // but they're quite sensible.
+        }), { throwOnTimeout: true });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    callWithOptions(options, callable, ...args) {
+        // Note this doesn't cancel the underlying request,
+        // when available prefer to use the signal option of the underlying call
+        if (options.signal) {
+            return Promise.race([
+                this.call(callable, ...args),
+                new Promise((_, reject) => {
+                    options.signal?.addEventListener("abort", () => {
+                        reject(new Error("AbortError"));
+                    });
+                }),
+            ]);
+        }
+        return this.call(callable, ...args);
+    }
+    fetch(...args) {
+        return this.call(() => fetch(...args).then((res) => (res.ok ? res : Promise.reject(res))));
+    }
+}

package/dist/utils/env.cjs

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setEnvironmentVariable = exports.getEnvironmentVariable = exports.getRuntimeEnvironment = exports.getEnv = exports.isNode = exports.isDeno = exports.isJsDom = exports.isWebWorker = exports.isBrowser = void 0;
+const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
+exports.isBrowser = isBrowser;
+const isWebWorker = () => typeof globalThis === "object" &&
+    globalThis.constructor &&
+    globalThis.constructor.name === "DedicatedWorkerGlobalScope";
+exports.isWebWorker = isWebWorker;
+const isJsDom = () => (typeof window !== "undefined" && window.name === "nodejs") ||
+    (typeof navigator !== "undefined" &&
+        (navigator.userAgent.includes("Node.js") ||
+            navigator.userAgent.includes("jsdom")));
+exports.isJsDom = isJsDom;
+// Supabase Edge Function provides a `Deno` global object
+// without `version` property
+const isDeno = () => typeof Deno !== "undefined";
+exports.isDeno = isDeno;
+// Mark not-as-node if in Supabase Edge Function
+const isNode = () => typeof process !== "undefined" &&
+    typeof process.versions !== "undefined" &&
+    typeof process.versions.node !== "undefined" &&
+    !(0, exports.isDeno)();
+exports.isNode = isNode;
+const getEnv = () => {
+    let env;
+    if ((0, exports.isBrowser)()) {
+        env = "browser";
+    }
+    else if ((0, exports.isNode)()) {
+        env = "node";
+    }
+    else if ((0, exports.isWebWorker)()) {
+        env = "webworker";
+    }
+    else if ((0, exports.isJsDom)()) {
+        env = "jsdom";
+    }
+    else if ((0, exports.isDeno)()) {
+        env = "deno";
+    }
+    else {
+        env = "other";
+    }
+    return env;
+};
+exports.getEnv = getEnv;
+let runtimeEnvironment;
+async function getRuntimeEnvironment() {
+    if (runtimeEnvironment === undefined) {
+        const env = (0, exports.getEnv)();
+        runtimeEnvironment = {
+            library: "langsmith",
+            runtime: env,
+        };
+    }
+    return runtimeEnvironment;
+}
+exports.getRuntimeEnvironment = getRuntimeEnvironment;
+function getEnvironmentVariable(name) {
+    // Certain Deno setups will throw an error if you try to access environment variables
+    // https://github.com/hwchase17/langchainjs/issues/1412
+    try {
+        return typeof process !== "undefined"
+            ? // eslint-disable-next-line no-process-env
+                process.env?.[name]
+            : undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+exports.getEnvironmentVariable = getEnvironmentVariable;
+function setEnvironmentVariable(name, value) {
+    if (typeof process !== "undefined") {
+        // eslint-disable-next-line no-process-env
+        process.env[name] = value;
+    }
+}
+exports.setEnvironmentVariable = setEnvironmentVariable;

package/dist/utils/env.d.ts

@@ -0,0 +1,22 @@
+declare global {
+    const Deno: {
+        version: {
+            deno: string;
+        };
+    } | undefined;
+}
+export declare const isBrowser: () => boolean;
+export declare const isWebWorker: () => boolean;
+export declare const isJsDom: () => boolean;
+export declare const isDeno: () => boolean;
+export declare const isNode: () => boolean;
+export declare const getEnv: () => string;
+export type RuntimeEnvironment = {
+    library: string;
+    libraryVersion?: string;
+    runtime: string;
+    runtimeVersion?: string;
+};
+export declare function getRuntimeEnvironment(): Promise<RuntimeEnvironment>;
+export declare function getEnvironmentVariable(name: string): string | undefined;
+export declare function setEnvironmentVariable(name: string, value: string): void;

package/dist/utils/env.js

@@ -0,0 +1,68 @@
+export const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
+export const isWebWorker = () => typeof globalThis === "object" &&
+    globalThis.constructor &&
+    globalThis.constructor.name === "DedicatedWorkerGlobalScope";
+export const isJsDom = () => (typeof window !== "undefined" && window.name === "nodejs") ||
+    (typeof navigator !== "undefined" &&
+        (navigator.userAgent.includes("Node.js") ||
+            navigator.userAgent.includes("jsdom")));
+// Supabase Edge Function provides a `Deno` global object
+// without `version` property
+export const isDeno = () => typeof Deno !== "undefined";
+// Mark not-as-node if in Supabase Edge Function
+export const isNode = () => typeof process !== "undefined" &&
+    typeof process.versions !== "undefined" &&
+    typeof process.versions.node !== "undefined" &&
+    !isDeno();
+export const getEnv = () => {
+    let env;
+    if (isBrowser()) {
+        env = "browser";
+    }
+    else if (isNode()) {
+        env = "node";
+    }
+    else if (isWebWorker()) {
+        env = "webworker";
+    }
+    else if (isJsDom()) {
+        env = "jsdom";
+    }
+    else if (isDeno()) {
+        env = "deno";
+    }
+    else {
+        env = "other";
+    }
+    return env;
+};
+let runtimeEnvironment;
+export async function getRuntimeEnvironment() {
+    if (runtimeEnvironment === undefined) {
+        const env = getEnv();
+        runtimeEnvironment = {
+            library: "langsmith",
+            runtime: env,
+        };
+    }
+    return runtimeEnvironment;
+}
+export function getEnvironmentVariable(name) {
+    // Certain Deno setups will throw an error if you try to access environment variables
+    // https://github.com/hwchase17/langchainjs/issues/1412
+    try {
+        return typeof process !== "undefined"
+            ? // eslint-disable-next-line no-process-env
+                process.env?.[name]
+            : undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+export function setEnvironmentVariable(name, value) {
+    if (typeof process !== "undefined") {
+        // eslint-disable-next-line no-process-env
+        process.env[name] = value;
+    }
+}

package/evaluation.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/evaluation/index.cjs');

package/evaluation.d.ts

@@ -0,0 +1 @@
+export * from './dist/evaluation/index.js'

package/evaluation.js

@@ -0,0 +1 @@
+export * from './dist/evaluation/index.js'

package/index.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/index.cjs');

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist/index.js'

package/index.js

@@ -0,0 +1 @@
+export * from './dist/index.js'