@nocobase/plugin-ai 1.9.33 → 1.9.34

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/traceable.js

@@ -1,14 +1,79 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { RunTree, isRunTree, isRunnableConfigLike, } from "./run_trees.js";
 import { isTracingEnabled } from "./env.js";
-import { ROOT, AsyncLocalStorageProviderSingleton, } from "./singletons/traceable.js";
+import { ROOT, AsyncLocalStorageProviderSingleton, getCurrentRunTree, } from "./singletons/traceable.js";
 import { _LC_CONTEXT_VARIABLES_KEY } from "./singletons/constants.js";
 import { isKVMap, isReadableStream, isAsyncIterable, isIteratorLike, isThenable, isGenerator, isPromiseMethod, } from "./utils/asserts.js";
+import { getOtelEnabled } from "./utils/env.js";
+import { __version__ } from "./index.js";
+import { getOTELTrace, getOTELContext } from "./singletons/otel.js";
+import { getUuidFromOtelSpanId } from "./experimental/otel/utils.js";
+import { LANGSMITH_REFERENCE_EXAMPLE_ID, LANGSMITH_SESSION_NAME, LANGSMITH_TRACEABLE, } from "./experimental/otel/constants.js";
 AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
+/**
+ * Create OpenTelemetry context manager from RunTree if OTEL is enabled.
+ */
+function maybeCreateOtelContext(runTree, projectName, tracer
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (!runTree || !getOtelEnabled()) {
+        return;
+    }
+    const otel_trace = getOTELTrace();
+    try {
+        const activeTraceId = otel_trace.getActiveSpan()?.spanContext()?.traceId;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (fn) => {
+            const resolvedTracer = tracer ?? otel_trace.getTracer("langsmith", __version__);
+            const attributes = {
+                [LANGSMITH_TRACEABLE]: "true",
+            };
+            if (runTree.reference_example_id) {
+                attributes[LANGSMITH_REFERENCE_EXAMPLE_ID] =
+                    runTree.reference_example_id;
+            }
+            if (projectName !== undefined) {
+                attributes[LANGSMITH_SESSION_NAME] = projectName;
+            }
+            const forceOTELRoot = runTree.extra?.ls_otel_root === true;
+            return resolvedTracer.startActiveSpan(runTree.name, {
+                attributes,
+                root: forceOTELRoot,
+            }, () => {
+                if (activeTraceId === undefined || forceOTELRoot) {
+                    const otelSpanId = otel_trace
+                        .getActiveSpan()
+                        ?.spanContext()?.spanId;
+                    if (otelSpanId) {
+                        const langsmithTraceId = getUuidFromOtelSpanId(otelSpanId);
+                        // Must refetch from our primary async local storage
+                        const currentRunTree = getCurrentRunTree();
+                        if (currentRunTree) {
+                            // This is only for root runs to ensure that trace id
+                            // and the root run id are returned correctly.
+                            // This is important for things like leaving feedback on
+                            // target function runs during evaluation.
+                            currentRunTree.id = langsmithTraceId;
+                            currentRunTree.trace_id = langsmithTraceId;
+                        }
+                    }
+                }
+                return fn();
+            });
+        };
+    }
+    catch {
+        // Silent failure if OTEL setup is incomplete
+        return;
+    }
+}
 const runInputsToMap = (rawInputs) => {
     const firstInput = rawInputs[0];
     let inputs;
-    if (firstInput == null) {
+    if (firstInput === null) {
+        inputs = { inputs: null };
+    }
+    else if (firstInput === undefined) {
         inputs = {};
     }
     else if (rawInputs.length > 1) {
@@ -31,22 +96,98 @@ const handleRunInputs = (inputs, processInputs) => {
         return inputs;
     }
 };
-const handleRunOutputs = (rawOutputs, processOutputs) => {
+const _extractUsage = (runData) => {
+    const usageMetadataFromMetadata = (runData.runTree.extra.metadata ?? {})
+        .usage_metadata;
+    return runData.outputs?.usage_metadata ?? usageMetadataFromMetadata;
+};
+async function handleEnd(params) {
+    const { runTree, on_end, postRunPromise, excludeInputs } = params;
+    const onEnd = on_end;
+    if (onEnd) {
+        if (!runTree) {
+            console.warn("Can not call 'on_end' if currentRunTree is undefined");
+        }
+        else {
+            onEnd(runTree);
+        }
+    }
+    await postRunPromise;
+    await runTree?.patchRun({
+        excludeInputs,
+    });
+}
+const _populateUsageMetadata = (processedOutputs, runTree) => {
+    if (runTree !== undefined) {
+        let usageMetadata;
+        try {
+            usageMetadata = _extractUsage({ runTree, outputs: processedOutputs });
+        }
+        catch (e) {
+            console.error("Error occurred while extracting usage metadata:", e);
+        }
+        if (usageMetadata !== undefined) {
+            runTree.extra.metadata = {
+                ...runTree.extra.metadata,
+                usage_metadata: usageMetadata,
+            };
+            processedOutputs.usage_metadata = usageMetadata;
+        }
+    }
+};
+function isAsyncFn(fn) {
+    return (fn != null &&
+        typeof fn === "function" &&
+        fn.constructor.name === "AsyncFunction");
+}
+// Note: This mutates the run tree
+async function handleRunOutputs(params) {
+    const { runTree, rawOutputs, processOutputsFn, on_end, postRunPromise, excludeInputs, } = params;
     let outputs;
     if (isKVMap(rawOutputs)) {
-        outputs = rawOutputs;
+        outputs = { ...rawOutputs };
     }
     else {
         outputs = { outputs: rawOutputs };
     }
     try {
-        return processOutputs(outputs);
+        outputs = processOutputsFn(outputs);
+        // TODO: Investigate making this behavior for all returned promises
+        // on next minor bump.
+        if (isAsyncFn(processOutputsFn)) {
+            void outputs
+                .then(async (processedOutputs) => {
+                _populateUsageMetadata(processedOutputs, runTree);
+                await runTree?.end(processedOutputs);
+            })
+                .catch(async (e) => {
+                console.error("Error occurred during processOutputs. Sending unprocessed outputs:", e);
+                try {
+                    await runTree?.end(outputs);
+                }
+                catch (e) {
+                    console.error("Error occurred during runTree?.end.", e);
+                }
+            })
+                .finally(async () => {
+                try {
+                    await handleEnd({ runTree, postRunPromise, on_end, excludeInputs });
+                }
+                catch (e) {
+                    console.error("Error occurred during handleEnd.", e);
+                }
+            });
+            return;
+        }
     }
     catch (e) {
-        console.error("Error occurred during processOutputs. Sending raw outputs:", e);
-        return outputs;
+        console.error("Error occurred during processOutputs. Sending unprocessed outputs:", e);
     }
-};
+    _populateUsageMetadata(outputs, runTree);
+    await runTree?.end(outputs);
+    await handleEnd({ runTree, postRunPromise, on_end, excludeInputs });
+    return;
+}
 const handleRunAttachments = (rawInputs, extractAttachments) => {
     if (!extractAttachments) {
         return [undefined, rawInputs];
@@ -62,7 +203,7 @@ const handleRunAttachments = (rawInputs, extractAttachments) => {
 };
 const getTracingRunTree = (runTree, inputs, getInvocationParams, processInputs, extractAttachments) => {
     if (!isTracingEnabled(runTree.tracingEnabled)) {
-        return undefined;
+        return {};
     }
     const [attached, args] = handleRunAttachments(inputs, extractAttachments);
     runTree.attachments = attached;
@@ -134,11 +275,11 @@ const convertSerializableArg = (arg) => {
         });
         const pipeThrough = arg.pipeThrough(transform);
         Object.assign(pipeThrough, { toJSON: () => proxyState });
-        return pipeThrough;
+        return { converted: pipeThrough, deferredInput: true };
     }
     if (isAsyncIterable(arg)) {
         const proxyState = { current: [] };
-        return new Proxy(arg, {
+        const converted = new Proxy(arg, {
             get(target, prop, receiver) {
                 if (prop === Symbol.asyncIterator) {
                     return () => {
@@ -178,15 +319,15 @@ const convertSerializableArg = (arg) => {
                 return Reflect.get(target, prop, receiver);
             },
         });
+        return { converted, deferredInput: true };
     }
     if (!Array.isArray(arg) && isIteratorLike(arg)) {
         const proxyState = [];
-        return new Proxy(arg, {
+        const converted = new Proxy(arg, {
             get(target, prop, receiver) {
                 if (prop === "next" || prop === "return" || prop === "throw") {
                     const bound = arg[prop]?.bind(arg);
                     return (...args) => {
-                        // @ts-expect-error TS cannot infer the argument types for the bound function
                         const next = bound?.(...args);
                         if (next != null)
                             proxyState.push(next);
@@ -206,11 +347,12 @@ const convertSerializableArg = (arg) => {
                 return Reflect.get(target, prop, receiver);
             },
         });
+        return { converted, deferredInput: true };
     }
     if (isThenable(arg)) {
-        return getSerializablePromise(arg);
+        return { converted: getSerializablePromise(arg), deferredInput: true };
     }
-    return arg;
+    return { converted: arg, deferredInput: false };
 };
 /**
  * Higher-order function that takes function as input and returns a
@@ -281,10 +423,13 @@ export function traceable(wrappedFunc, config) {
         const asyncLocalStorage = AsyncLocalStorageProviderSingleton.getInstance();
         // TODO: deal with possible nested promises and async iterables
         const processedArgs = args;
+        let deferredInput = false;
         for (let i = 0; i < processedArgs.length; i++) {
-            processedArgs[i] = convertSerializableArg(processedArgs[i]);
+            const { converted, deferredInput: argDefersInput } = convertSerializableArg(processedArgs[i]);
+            processedArgs[i] = converted;
+            deferredInput = deferredInput || argDefersInput;
         }
-        const [currentRunTree, rawInputs] = (() => {
+        const [currentContext, rawInputs] = (() => {
             const [firstArg, ...restArgs] = processedArgs;
             // used for handoff between LangChain.JS and traceable functions
             if (isRunnableConfigLike(firstArg)) {
@@ -311,25 +456,35 @@ export function traceable(wrappedFunc, config) {
             // Node.JS uses AsyncLocalStorage (ALS) and AsyncResource
             // to allow storing context
             const prevRunFromStore = asyncLocalStorage.getStore();
-            if (isRunTree(prevRunFromStore)) {
-                return [
-                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn),
-                    processedArgs,
-                ];
-            }
-            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+            let lc_contextVars;
             // If a context var is set by LangChain outside of a traceable,
             // it will be an object with a single property and we should copy
             // context vars over into the new run tree.
             if (prevRunFromStore !== undefined &&
                 _LC_CONTEXT_VARIABLES_KEY in prevRunFromStore) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                currentRunTree[_LC_CONTEXT_VARIABLES_KEY] =
-                    prevRunFromStore[_LC_CONTEXT_VARIABLES_KEY];
+                lc_contextVars = prevRunFromStore[_LC_CONTEXT_VARIABLES_KEY];
+            }
+            if (isRunTree(prevRunFromStore)) {
+                const currentRunTree = getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+                if (lc_contextVars) {
+                    (currentRunTree ?? {})[_LC_CONTEXT_VARIABLES_KEY] =
+                        lc_contextVars;
+                }
+                return [currentRunTree, processedArgs];
+            }
+            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+            if (lc_contextVars) {
+                (currentRunTree ?? {})[_LC_CONTEXT_VARIABLES_KEY] =
+                    lc_contextVars;
             }
             return [currentRunTree, processedArgs];
         })();
-        return asyncLocalStorage.run(currentRunTree, () => {
+        const currentRunTree = isRunTree(currentContext)
+            ? currentContext
+            : undefined;
+        const otelContextManager = maybeCreateOtelContext(currentRunTree, config?.project_name, config?.tracer);
+        const otel_context = getOTELContext();
+        const runWithContext = () => {
             const postRunPromise = currentRunTree?.postRun();
             async function handleChunks(chunks) {
                 if (aggregator !== undefined) {
@@ -346,17 +501,24 @@ export function traceable(wrappedFunc, config) {
                 const reader = stream.getReader();
                 let finished = false;
                 const chunks = [];
+                const capturedOtelContext = otel_context.active();
                 const tappedStream = new ReadableStream({
                     async start(controller) {
                         // eslint-disable-next-line no-constant-condition
                         while (true) {
                             const result = await (snapshot
-                                ? snapshot(() => reader.read())
-                                : reader.read());
+                                ? snapshot(() => otel_context.with(capturedOtelContext, () => reader.read()))
+                                : otel_context.with(capturedOtelContext, () => reader.read()));
                             if (result.done) {
                                 finished = true;
-                                await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks), processOutputsFn));
-                                await handleEnd();
+                                await handleRunOutputs({
+                                    runTree: currentRunTree,
+                                    rawOutputs: await handleChunks(chunks),
+                                    processOutputsFn,
+                                    on_end: config?.on_end,
+                                    postRunPromise,
+                                    excludeInputs: !deferredInput,
+                                });
                                 controller.close();
                                 break;
                             }
@@ -374,8 +536,14 @@ export function traceable(wrappedFunc, config) {
                     async cancel(reason) {
                         if (!finished)
                             await currentRunTree?.end(undefined, "Cancelled");
-                        await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks), processOutputsFn));
-                        await handleEnd();
+                        await handleRunOutputs({
+                            runTree: currentRunTree,
+                            rawOutputs: await handleChunks(chunks),
+                            processOutputsFn,
+                            on_end: config?.on_end,
+                            postRunPromise,
+                            excludeInputs: !deferredInput,
+                        });
                         return reader.cancel(reason);
                     },
                 });
@@ -384,11 +552,12 @@ export function traceable(wrappedFunc, config) {
             async function* wrapAsyncIteratorForTracing(iterator, snapshot) {
                 let finished = false;
                 const chunks = [];
+                const capturedOtelContext = otel_context.active();
                 try {
                     while (true) {
                         const { value, done } = await (snapshot
-                            ? snapshot(() => iterator.next())
-                            : iterator.next());
+                            ? snapshot(() => otel_context.with(capturedOtelContext, () => iterator.next()))
+                            : otel_context.with(capturedOtelContext, () => iterator.next()));
                         if (done) {
                             finished = true;
                             break;
@@ -411,8 +580,14 @@ export function traceable(wrappedFunc, config) {
                 finally {
                     if (!finished)
                         await currentRunTree?.end(undefined, "Cancelled");
-                    await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks), processOutputsFn));
-                    await handleEnd();
+                    await handleRunOutputs({
+                        runTree: currentRunTree,
+                        rawOutputs: await handleChunks(chunks),
+                        processOutputsFn,
+                        on_end: config?.on_end,
+                        postRunPromise,
+                        excludeInputs: !deferredInput,
+                    });
                 }
             }
             function wrapAsyncGeneratorForTracing(iterable, snapshot) {
@@ -424,19 +599,6 @@ export function traceable(wrappedFunc, config) {
                 iterable[Symbol.asyncIterator] = () => wrappedIterator;
                 return iterable;
             }
-            async function handleEnd() {
-                const onEnd = config?.on_end;
-                if (onEnd) {
-                    if (!currentRunTree) {
-                        console.warn("Can not call 'on_end' if currentRunTree is undefined");
-                    }
-                    else {
-                        onEnd(currentRunTree);
-                    }
-                }
-                await postRunPromise;
-                await currentRunTree?.patchRun();
-            }
             function gatherAll(iterator) {
                 const chunks = [];
                 // eslint-disable-next-line no-constant-condition
@@ -491,16 +653,22 @@ export function traceable(wrappedFunc, config) {
                     if (isGenerator(wrappedFunc) && isIteratorLike(rawOutput)) {
                         const chunks = gatherAll(rawOutput);
                         try {
-                            await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks.reduce((memo, { value, done }) => {
-                                if (!done || typeof value !== "undefined") {
-                                    memo.push(value);
-                                }
-                                return memo;
-                            }, [])), processOutputsFn));
-                            await handleEnd();
+                            await handleRunOutputs({
+                                runTree: currentRunTree,
+                                rawOutputs: await handleChunks(chunks.reduce((memo, { value, done }) => {
+                                    if (!done || typeof value !== "undefined") {
+                                        memo.push(value);
+                                    }
+                                    return memo;
+                                }, [])),
+                                processOutputsFn,
+                                on_end: config?.on_end,
+                                postRunPromise,
+                                excludeInputs: !deferredInput,
+                            });
                         }
                         catch (e) {
-                            console.error("Error occurred during handleEnd:", e);
+                            console.error("[LANGSMITH]: Error occurred while handling run outputs:", e);
                         }
                         return (function* () {
                             for (const ret of chunks) {
@@ -511,8 +679,14 @@ export function traceable(wrappedFunc, config) {
                         })();
                     }
                     try {
-                        await currentRunTree?.end(handleRunOutputs(rawOutput, processOutputsFn));
-                        await handleEnd();
+                        await handleRunOutputs({
+                            runTree: currentRunTree,
+                            rawOutputs: rawOutput,
+                            processOutputsFn,
+                            on_end: config?.on_end,
+                            postRunPromise,
+                            excludeInputs: !deferredInput,
+                        });
                     }
                     finally {
                         // eslint-disable-next-line no-unsafe-finally
@@ -520,7 +694,12 @@ export function traceable(wrappedFunc, config) {
                     }
                 }, async (error) => {
                     await currentRunTree?.end(undefined, String(error));
-                    await handleEnd();
+                    await handleEnd({
+                        runTree: currentRunTree,
+                        postRunPromise,
+                        on_end: config?.on_end,
+                        excludeInputs: !deferredInput,
+                    });
                     throw error;
                 })
                     .then(resolve, reject);
@@ -536,7 +715,14 @@ export function traceable(wrappedFunc, config) {
                     return Reflect.get(target, prop, receiver);
                 },
             });
-        });
+        };
+        // Wrap with OTEL context if available, similar to Python's implementation
+        if (otelContextManager) {
+            return asyncLocalStorage.run(currentContext, () => otelContextManager(runWithContext));
+        }
+        else {
+            return asyncLocalStorage.run(currentContext, runWithContext);
+        }
     };
     Object.defineProperty(traceableFunc, "langsmith:traceable", {
         value: runTreeConfig,

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/_uuid.cjs

@@ -1,32 +1,12 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertUuid = void 0;
-const uuid = __importStar(require("uuid"));
+exports.assertUuid = assertUuid;
+// Relaxed UUID validation regex (allows any valid UUID format including nil UUIDs)
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function assertUuid(str, which) {
-    if (!uuid.validate(str)) {
+    // Use relaxed regex validation instead of strict uuid.validate()
+    // This allows edge cases like nil UUIDs or test UUIDs that might not pass strict validation
+    if (!UUID_REGEX.test(str)) {
         const msg = which !== undefined
             ? `Invalid UUID for ${which}: ${str}`
             : `Invalid UUID: ${str}`;
@@ -34,4 +14,3 @@ function assertUuid(str, which) {
     }
     return str;
 }
-exports.assertUuid = assertUuid;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/_uuid.js

@@ -1,6 +1,9 @@
-import * as uuid from "uuid";
+// Relaxed UUID validation regex (allows any valid UUID format including nil UUIDs)
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 export function assertUuid(str, which) {
-    if (!uuid.validate(str)) {
+    // Use relaxed regex validation instead of strict uuid.validate()
+    // This allows edge cases like nil UUIDs or test UUIDs that might not pass strict validation
+    if (!UUID_REGEX.test(str)) {
         const msg = which !== undefined
             ? `Invalid UUID for ${which}: ${str}`
             : `Invalid UUID: ${str}`;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/asserts.cjs

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReadableStream = exports.isThenable = exports.isGenerator = exports.isIteratorLike = exports.isAsyncIterable = exports.isKVMap = exports.isPromiseMethod = void 0;
+exports.isReadableStream = exports.isThenable = exports.isGenerator = exports.isIteratorLike = exports.isAsyncIterable = void 0;
+exports.isPromiseMethod = isPromiseMethod;
+exports.isKVMap = isKVMap;
 function isPromiseMethod(x) {
     if (x === "then" || x === "catch" || x === "finally") {
         return true;
     }
     return false;
 }
-exports.isPromiseMethod = isPromiseMethod;
 function isKVMap(x) {
     if (typeof x !== "object" || x == null) {
         return false;
@@ -19,7 +20,6 @@ function isKVMap(x) {
         !(Symbol.toStringTag in x) &&
         !(Symbol.iterator in x));
 }
-exports.isKVMap = isKVMap;
 const isAsyncIterable = (x) => x != null &&
     typeof x === "object" &&
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/asserts.d.ts

@@ -1,7 +1,7 @@
 export declare function isPromiseMethod(x: string | symbol): x is "then" | "catch" | "finally";
 export declare function isKVMap(x: unknown): x is Record<string, unknown>;
 export declare const isAsyncIterable: (x: unknown) => x is AsyncIterable<unknown>;
-export declare const isIteratorLike: (x: unknown) => x is Iterator<unknown, any, undefined>;
-export declare const isGenerator: (x: unknown) => x is Generator<unknown, any, unknown>;
+export declare const isIteratorLike: (x: unknown) => x is Iterator<unknown>;
+export declare const isGenerator: (x: unknown) => x is Generator;
 export declare const isThenable: (x: unknown) => x is Promise<unknown>;
-export declare const isReadableStream: (x: unknown) => x is ReadableStream<any>;
+export declare const isReadableStream: (x: unknown) => x is ReadableStream;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/async_caller.cjs

@@ -6,19 +6,12 @@ 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 fetch_js_1 = require("../singletons/fetch.cjs");
-const STATUS_NO_RETRY = [
-    400, // Bad Request
-    401, // Unauthorized
-    403, // Forbidden
-    404, // Not Found
-    405, // Method Not Allowed
-    406, // Not Acceptable
-    407, // Proxy Authentication Required
-    408, // Request Timeout
-];
-const STATUS_IGNORE = [
-    409, // Conflict
+const STATUS_RETRYABLE = [
+    429, // Too Many Requests
+    500, // Internal Server Error
+    502, // Bad Gateway
+    503, // Service Unavailable
+    504, // Gateway Timeout
 ];
 /**
  * A class that can be used to make async calls with concurrency and retry logic.
@@ -85,33 +78,31 @@ class AsyncCaller {
                 throw new Error(error);
             }
         }), {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             async onFailedAttempt(error) {
                 if (error.message.startsWith("Cancel") ||
                     error.message.startsWith("TimeoutError") ||
+                    error.name === "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 response = error?.response;
-                const status = response?.status;
-                if (status) {
-                    if (STATUS_NO_RETRY.includes(+status)) {
-                        throw error;
-                    }
-                    else if (STATUS_IGNORE.includes(+status)) {
+                if (onFailedResponseHook) {
+                    const handled = await onFailedResponseHook(response);
+                    if (handled) {
                         return;
                     }
-                    if (onFailedResponseHook) {
-                        await onFailedResponseHook(response);
+                }
+                const status = response?.status ?? error?.status;
+                if (status) {
+                    if (!STATUS_RETRYABLE.includes(+status)) {
+                        throw error;
                     }
                 }
             },
-            // If needed we can change some of the defaults here,
-            // but they're quite sensible.
             retries: this.maxRetries,
             randomize: true,
         }), { throwOnTimeout: true });
@@ -132,8 +123,5 @@ class AsyncCaller {
         }
         return this.call(callable, ...args);
     }
-    fetch(...args) {
-        return this.call(() => (0, fetch_js_1._getFetchImplementation)()(...args).then((res) => res.ok ? res : Promise.reject(res)));
-    }
 }
 exports.AsyncCaller = AsyncCaller;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/async_caller.d.ts

@@ -11,6 +11,7 @@ export interface AsyncCallerParams {
      */
     maxRetries?: number;
     onFailedResponseHook?: ResponseCallback;
+    debug?: boolean;
 }
 export interface AsyncCallerCallOptions {
     signal?: AbortSignal;
@@ -36,6 +37,5 @@ export declare class AsyncCaller {
     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>;
 }
 export {};