langsmith 0.2.15-rc.8 → 0.2.15

package/dist/client.cjs

@@ -2555,6 +2555,34 @@ class Client {
         await (0, error_js_1.raiseForStatus)(response, "get run from annotation queue");
         return await response.json();
     }
+    /**
+     * Delete a run from an an annotation queue.
+     * @param queueId - The ID of the annotation queue to delete the run from
+     * @param queueRunId - The ID of the run to delete from the annotation queue
+     */
+    async deleteRunFromAnnotationQueue(queueId, queueRunId) {
+        const response = await this.caller.call((0, fetch_js_1._getFetchImplementation)(), `${this.apiUrl}/annotation-queues/${(0, _uuid_js_1.assertUuid)(queueId, "queueId")}/runs/${(0, _uuid_js_1.assertUuid)(queueRunId, "queueRunId")}`, {
+            method: "DELETE",
+            headers: { ...this.headers, Accept: "application/json" },
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        await (0, error_js_1.raiseForStatus)(response, "delete run from annotation queue");
+    }
+    /**
+     * Get the size of an annotation queue.
+     * @param queueId - The ID of the annotation queue
+     */
+    async getSizeFromAnnotationQueue(queueId) {
+        const response = await this.caller.call((0, fetch_js_1._getFetchImplementation)(), `${this.apiUrl}/annotation-queues/${(0, _uuid_js_1.assertUuid)(queueId, "queueId")}/size`, {
+            method: "GET",
+            headers: this.headers,
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        await (0, error_js_1.raiseForStatus)(response, "get size from annotation queue");
+        return await response.json();
+    }
     async _currentTenantIsOwner(owner) {
         const settings = await this._getSettings();
         return owner == "-" || settings.tenant_handle === owner;

package/dist/client.d.ts

@@ -164,14 +164,6 @@ export type CreateExampleOptions = {
     /** The ID of the source run associated with this example. */
     sourceRunId?: string;
 };
-export type CreateProjectParams = {
-    projectName: string;
-    description?: string | null;
-    metadata?: RecordStringAny | null;
-    upsert?: boolean;
-    projectExtra?: RecordStringAny | null;
-    referenceDatasetId?: string | null;
-};
 type AutoBatchQueueItem = {
     action: "create" | "update";
     item: RunCreate | RunUpdate;
@@ -403,7 +395,14 @@ export declare class Client implements LangSmithTracingClientInterface {
     listSharedExamples(shareToken: string, options?: {
         exampleIds?: string[];
     }): Promise<Example[]>;
-    createProject({ projectName, description, metadata, upsert, projectExtra, referenceDatasetId, }: CreateProjectParams): Promise<TracerSession>;
+    createProject({ projectName, description, metadata, upsert, projectExtra, referenceDatasetId, }: {
+        projectName: string;
+        description?: string | null;
+        metadata?: RecordStringAny | null;
+        upsert?: boolean;
+        projectExtra?: RecordStringAny | null;
+        referenceDatasetId?: string | null;
+    }): Promise<TracerSession>;
     updateProject(projectId: string, { name, description, metadata, projectExtra, endTime, }: {
         name?: string | null;
         description?: string | null;
@@ -714,6 +713,19 @@ export declare class Client implements LangSmithTracingClientInterface {
      * @throws {Error} If the run is not found at the given index or for other API-related errors
      */
     getRunFromAnnotationQueue(queueId: string, index: number): Promise<RunWithAnnotationQueueInfo>;
+    /**
+     * Delete a run from an an annotation queue.
+     * @param queueId - The ID of the annotation queue to delete the run from
+     * @param queueRunId - The ID of the run to delete from the annotation queue
+     */
+    deleteRunFromAnnotationQueue(queueId: string, queueRunId: string): Promise<void>;
+    /**
+     * Get the size of an annotation queue.
+     * @param queueId - The ID of the annotation queue
+     */
+    getSizeFromAnnotationQueue(queueId: string): Promise<{
+        size: number;
+    }>;
     protected _currentTenantIsOwner(owner: string): Promise<boolean>;
     protected _ownerConflictError(action: string, owner: string): Promise<Error>;
     protected _getLatestCommitHash(promptOwnerAndName: string): Promise<string | undefined>;

package/dist/client.js

@@ -2527,6 +2527,34 @@ export class Client {
         await raiseForStatus(response, "get run from annotation queue");
         return await response.json();
     }
+    /**
+     * Delete a run from an an annotation queue.
+     * @param queueId - The ID of the annotation queue to delete the run from
+     * @param queueRunId - The ID of the run to delete from the annotation queue
+     */
+    async deleteRunFromAnnotationQueue(queueId, queueRunId) {
+        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/runs/${assertUuid(queueRunId, "queueRunId")}`, {
+            method: "DELETE",
+            headers: { ...this.headers, Accept: "application/json" },
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        await raiseForStatus(response, "delete run from annotation queue");
+    }
+    /**
+     * Get the size of an annotation queue.
+     * @param queueId - The ID of the annotation queue
+     */
+    async getSizeFromAnnotationQueue(queueId) {
+        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/size`, {
+            method: "GET",
+            headers: this.headers,
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        await raiseForStatus(response, "get size from annotation queue");
+        return await response.json();
+    }
     async _currentTenantIsOwner(owner) {
         const settings = await this._getSettings();
         return owner == "-" || settings.tenant_handle === owner;

package/dist/index.cjs

@@ -8,4 +8,4 @@ Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () {
 var fetch_js_1 = require("./singletons/fetch.cjs");
 Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true, get: function () { return fetch_js_1.overrideFetchImplementation; } });
 // Update using yarn bump-version
-exports.__version__ = "0.2.15-rc.8";
+exports.__version__ = "0.2.15";

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { Client, type ClientConfig, type LangSmithTracingClientInterface, } from
 export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
-export declare const __version__ = "0.2.15-rc.8";
+export declare const __version__ = "0.2.15";

package/dist/index.js

@@ -2,4 +2,4 @@ export { Client, } from "./client.js";
 export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 // Update using yarn bump-version
-export const __version__ = "0.2.15-rc.8";
+export const __version__ = "0.2.15";

package/dist/run_trees.d.ts

@@ -80,7 +80,7 @@ export declare class RunTree implements BaseRun {
     attachments?: Attachments;
     constructor(originalConfig: RunTreeConfig | RunTree);
     private static getDefaultConfig;
-    static getSharedClient(): Client;
+    private static getSharedClient;
     createChild(config: RunTreeConfig): RunTree;
     end(outputs?: KVMap, error?: string, endTime?: number, metadata?: KVMap): Promise<void>;
     private _convertToCreate;

package/dist/singletons/traceable.cjs

@@ -38,7 +38,7 @@ const getCurrentRunTree = () => {
         throw new Error([
             "Could not get the current run tree.",
             "",
-            "Please make sure you are calling this method within a traceable function and that tracing is enabled.",
+            "Please make sure you are calling this method within a traceable function or the tracing is enabled.",
         ].join("\n"));
     }
     return runTree;

package/dist/singletons/traceable.js

@@ -35,7 +35,7 @@ export const getCurrentRunTree = () => {
         throw new Error([
             "Could not get the current run tree.",
             "",
-            "Please make sure you are calling this method within a traceable function and that tracing is enabled.",
+            "Please make sure you are calling this method within a traceable function or the tracing is enabled.",
         ].join("\n"));
     }
     return runTree;

package/dist/vercel.cjs

@@ -107,15 +107,49 @@ const tryJson = (str) => {
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
-function convertToDottedOrderFormat([seconds, nanoseconds], runId, executionOrder) {
+function getDotOrder(item) {
+    const { startTime: [seconds, nanoseconds], id: runId, executionOrder, } = item;
     // Date only has millisecond precision, so we use the microseconds to break
     // possible ties, avoiding incorrect run order
-    const ms = Number(String(nanoseconds).slice(0, 3));
-    const ns = String(Number(String(nanoseconds).slice(3, 6)) + executionOrder)
-        .padStart(3, "0")
-        .slice(0, 3);
+    const nanosecondString = String(nanoseconds).padStart(9, "0");
+    const msFull = Number(nanosecondString.slice(0, 6)) + executionOrder;
+    const msString = String(msFull).padStart(6, "0");
+    const ms = Number(msString.slice(0, -3));
+    const ns = msString.slice(-3);
     return (stripNonAlphanumeric(`${new Date(seconds * 1000 + ms).toISOString().slice(0, -1)}${ns}Z`) + runId);
 }
+function joinDotOrder(...segments) {
+    return segments.filter(Boolean).join(".");
+}
+function removeDotOrder(dotOrder, ...ids) {
+    return dotOrder
+        .split(".")
+        .filter((i) => !ids.some((id) => i.includes(id)))
+        .join(".");
+}
+function reparentDotOrder(dotOrder, sourceRunId, parentDotOrder) {
+    const segments = dotOrder.split(".");
+    const sourceIndex = segments.findIndex((i) => i.includes(sourceRunId));
+    if (sourceIndex === -1)
+        return dotOrder;
+    return joinDotOrder(...parentDotOrder.split("."), ...segments.slice(sourceIndex));
+}
+function getMutableRunCreate(dotOrder) {
+    const segments = dotOrder.split(".").map((i) => {
+        const [startTime, runId] = i.split("Z");
+        return { startTime, runId };
+    });
+    const traceId = segments[0].runId;
+    const parentRunId = segments.at(-2)?.runId;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const runId = segments.at(-1).runId;
+    return {
+        id: runId,
+        trace_id: traceId,
+        dotted_order: dotOrder,
+        parent_run_id: parentRunId,
+    };
+}
 function convertToTimestamp([seconds, nanoseconds]) {
     const ms = String(nanoseconds).slice(0, 3);
     return Number(String(seconds) + ms);
@@ -256,6 +290,8 @@ class AISDKExporter {
     }
     /** @internal */
     parseInteropFromMetadata(span) {
+        if (!this.isRootRun(span))
+            return undefined;
         const userTraceId = this.getSpanAttributeKey(span, RUN_ID_METADATA_KEY.output);
         const parentTrace = this.getSpanAttributeKey(span, TRACE_METADATA_KEY.output);
         if (parentTrace && userTraceId) {
@@ -271,15 +307,11 @@ class AISDKExporter {
             return { type: "traceable", parentRunTree };
         }
         if (userTraceId)
-            return { type: "user", userTraceId };
+            return { type: "user", userRunId: userTraceId };
         return undefined;
     }
     /** @internal */
     getRunCreate(span) {
-        const runId = (0, uuid_1.v5)(span.spanContext().spanId, RUN_ID_NAMESPACE);
-        const parentRunId = span.parentSpanId
-            ? (0, uuid_1.v5)(span.parentSpanId, RUN_ID_NAMESPACE)
-            : undefined;
         const asRunCreate = (rawConfig) => {
             const aiMetadata = Object.keys(span.attributes)
                 .filter((key) => key.startsWith("ai.telemetry.metadata.") &&
@@ -307,8 +339,6 @@ class AISDKExporter {
             const config = {
                 ...rawConfig,
                 name,
-                id: runId,
-                parent_run_id: parentRunId,
                 extra: {
                     ...rawConfig.extra,
                     metadata: {
@@ -540,43 +570,33 @@ class AISDKExporter {
                 relativeExecutionOrder: {},
             };
             const runId = (0, uuid_1.v5)(spanId, RUN_ID_NAMESPACE);
-            let parentRunId = parentId
+            const parentRunId = parentId
                 ? (0, uuid_1.v5)(parentId, RUN_ID_NAMESPACE)
                 : undefined;
-            // in LangSmith we currently only support certain spans
-            // which may be deeply nested within other traces
-            if (this.isRootRun(span))
-                parentRunId = undefined;
             const traceMap = this.traceByMap[traceId];
             const run = this.getRunCreate(span);
-            if (!run) {
-                this.logDebug("skipping span", span);
-                continue;
-            }
             traceMap.relativeExecutionOrder[parentRunId ?? ROOT] ??= -1;
             traceMap.relativeExecutionOrder[parentRunId ?? ROOT] += 1;
             traceMap.nodeMap[runId] ??= {
                 id: runId,
-                parentId: parentRunId,
                 startTime: span.startTime,
                 run,
                 sent: false,
+                interop: this.parseInteropFromMetadata(span),
                 executionOrder: traceMap.relativeExecutionOrder[parentRunId ?? ROOT],
             };
             if (this.debug)
                 console.log(`[${span.name}] ${runId}`, run);
             traceMap.childMap[parentRunId ?? ROOT] ??= [];
             traceMap.childMap[parentRunId ?? ROOT].push(traceMap.nodeMap[runId]);
-            traceMap.interop = this.parseInteropFromMetadata(span);
         }
-        // We separate `id`,
         const sampled = [];
+        const actions = [];
         for (const traceId of Object.keys(this.traceByMap)) {
             const traceMap = this.traceByMap[traceId];
             const queue = traceMap.childMap[ROOT]?.map((item) => ({
                 item,
-                dottedOrder: convertToDottedOrderFormat(item.startTime, item.id, item.executionOrder),
-                traceId: item.id,
+                dotOrder: getDotOrder(item),
             })) ?? [];
             const seen = new Set();
             while (queue.length) {
@@ -585,71 +605,57 @@ class AISDKExporter {
                 if (seen.has(task.item.id))
                     continue;
                 if (!task.item.sent) {
-                    let override = {
-                        id: task.item.id,
-                        parent_run_id: task.item.parentId,
-                        dotted_order: task.dottedOrder,
-                        trace_id: task.traceId,
-                    };
-                    if (traceMap.interop) {
-                        // attach the run to a parent run tree
-                        // - id: preserve
-                        // - parent_run_id: use existing parent run id or hook to the provided run tree
-                        // - dotted_order: append to the dotted_order of the parent run tree
-                        // - trace_id: use from the existing run tree
-                        if (traceMap.interop.type === "traceable") {
-                            override = {
-                                id: override.id,
-                                parent_run_id: override.parent_run_id ?? traceMap.interop.parentRunTree.id,
-                                dotted_order: [
-                                    traceMap.interop.parentRunTree.dotted_order,
-                                    override.dotted_order,
-                                ]
-                                    .filter(Boolean)
-                                    .join("."),
-                                trace_id: traceMap.interop.parentRunTree.trace_id,
-                            };
+                    if (task.item.run != null) {
+                        if (task.item.interop?.type === "user") {
+                            actions.push({
+                                type: "rename",
+                                sourceRunId: task.item.id,
+                                targetRunId: task.item.interop.userRunId,
+                            });
                         }
-                        else if (traceMap.interop.type === "user") {
-                            // Allow user to specify custom trace ID = run ID of the root run
-                            // - id: use user provided run ID if root run, otherwise preserve
-                            // - parent_run_id: use user provided run ID if root run, otherwise preserve
-                            // - dotted_order: replace the trace_id with the user provided run ID
-                            // - trace_id: use user provided run ID
-                            const userTraceId = traceMap.interop.userTraceId ?? (0, uuid_1.v4)();
-                            override = {
-                                id: override.id === override.trace_id ? userTraceId : override.id,
-                                parent_run_id: override.parent_run_id === override.trace_id
-                                    ? userTraceId
-                                    : override.parent_run_id,
-                                dotted_order: override.dotted_order.replace(override.trace_id, userTraceId),
-                                trace_id: userTraceId,
-                            };
+                        if (task.item.interop?.type === "traceable") {
+                            actions.push({
+                                type: "reparent",
+                                runId: task.item.id,
+                                parentDotOrder: task.item.interop.parentRunTree.dotted_order,
+                            });
+                        }
+                        let dotOrder = task.dotOrder;
+                        for (const action of actions) {
+                            if (action.type === "delete") {
+                                dotOrder = removeDotOrder(dotOrder, action.runId);
+                            }
+                            if (action.type === "reparent") {
+                                dotOrder = reparentDotOrder(dotOrder, action.runId, action.parentDotOrder);
+                            }
+                            if (action.type === "rename") {
+                                dotOrder = dotOrder.replace(action.sourceRunId, action.targetRunId);
+                            }
                         }
+                        sampled.push({
+                            ...task.item.run,
+                            ...getMutableRunCreate(dotOrder),
+                        });
+                    }
+                    else {
+                        actions.push({ type: "delete", runId: task.item.id });
                     }
-                    sampled.push([override, task.item.run]);
                     task.item.sent = true;
                 }
                 const children = traceMap.childMap[task.item.id] ?? [];
-                queue.push(...children.map((child) => {
-                    return {
-                        item: child,
-                        dottedOrder: [
-                            task.dottedOrder,
-                            convertToDottedOrderFormat(child.startTime, child.id, child.executionOrder),
-                        ].join("."),
-                        traceId: task.traceId,
-                    };
-                }));
+                queue.push(...children.map((item) => ({
+                    item,
+                    dotOrder: joinDotOrder(task.dotOrder, getDotOrder(item)),
+                })));
             }
         }
         this.logDebug(`sampled runs to be sent to LangSmith`, sampled);
-        Promise.all(sampled.map(([override, value]) => this.client.createRun({ ...value, ...override }))).then(() => resultCallback({ code: 0 }), (error) => resultCallback({ code: 1, error }));
+        Promise.all(sampled.map((run) => this.client.createRun(run))).then(() => resultCallback({ code: 0 }), (error) => resultCallback({ code: 1, error }));
     }
     async shutdown() {
         // find nodes which are incomplete
-        const incompleteNodes = Object.values(this.traceByMap).flatMap((trace) => Object.values(trace.nodeMap).filter((i) => !i.sent));
-        this.logDebug("shutting down", { incompleteNodes: incompleteNodes.length });
+        const incompleteNodes = Object.values(this.traceByMap).flatMap((trace) => Object.values(trace.nodeMap).filter((i) => !i.sent && i.run != null));
+        this.logDebug("shutting down", { incompleteNodes });
         if (incompleteNodes.length > 0) {
             console.warn("Some incomplete nodes were found before shutdown and not sent to LangSmith.");
         }