@langchain/core 0.2.2 → 0.2.4

package/dist/runnables/base.js

@@ -1,9 +1,10 @@
 import { z } from "zod";
 import pRetry from "p-retry";
 import { v4 as uuidv4 } from "uuid";
+import { isTraceableFunction, } from "langsmith/singletons/traceable";
 import { CallbackManager, } from "../callbacks/manager.js";
-import { LogStreamCallbackHandler, RunLog, RunLogPatch, } from "../tracers/log_stream.js";
-import { EventStreamCallbackHandler, } from "../tracers/event_stream.js";
+import { LogStreamCallbackHandler, RunLog, RunLogPatch, isLogStreamHandler, } from "../tracers/log_stream.js";
+import { EventStreamCallbackHandler, isStreamEventsHandler, } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, AsyncGeneratorWithSetup, } from "../utils/stream.js";
 import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
@@ -13,7 +14,7 @@ import { _RootEventFilter, isRunnableInterface } from "./utils.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 import { Graph } from "./graph.js";
 import { convertToHttpEventStream } from "./wrappers.js";
-import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterator, } from "./iter.js";
+import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterableIterator, isIterator, } from "./iter.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -280,13 +281,11 @@ export class Runnable extends Serializable {
             const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), config);
             delete config.runId;
             runManager = pipe.setup;
-            const isStreamEventsHandler = (handler) => handler.name === "event_stream_tracer";
             const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
             let iterator = pipe.output;
             if (streamEventsHandler !== undefined && runManager !== undefined) {
                 iterator = streamEventsHandler.tapOutputIterable(runManager.runId, iterator);
             }
-            const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
             if (streamLogHandler !== undefined && runManager !== undefined) {
                 iterator = streamLogHandler.tapOutputIterable(runManager.runId, iterator);
@@ -1374,6 +1373,68 @@ export class RunnableMap extends Runnable {
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
+/**
+ * A runnable that wraps a traced LangSmith function.
+ */
+export class RunnableTraceable extends Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!isTraceableFunction(fields.func)) {
+            throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
+        }
+        this.func = fields.func;
+    }
+    async invoke(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
+        const callbacks = await getCallbackManagerForConfig(config);
+        return (await this.func(patchConfig(config, { callbacks }), input));
+    }
+    async *_streamIterator(input, options) {
+        const result = await this.invoke(input, options);
+        if (isAsyncIterable(result)) {
+            for await (const item of result) {
+                yield item;
+            }
+            return;
+        }
+        if (isIterator(result)) {
+            while (true) {
+                const state = result.next();
+                if (state.done)
+                    break;
+                yield state.value;
+            }
+            return;
+        }
+        yield result;
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}
+function assertNonTraceableFunction(func) {
+    if (isTraceableFunction(func)) {
+        throw new Error("RunnableLambda requires a function that is not wrapped in traceable higher-order function. This shouldn't happen.");
+    }
+}
 /**
  * A runnable that runs a callable.
  */
@@ -1382,6 +1443,10 @@ export class RunnableLambda extends Runnable {
         return "RunnableLambda";
     }
     constructor(fields) {
+        if (isTraceableFunction(fields.func)) {
+            // eslint-disable-next-line no-constructor-return
+            return RunnableTraceable.from(fields.func);
+        }
         super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
@@ -1395,6 +1460,7 @@ export class RunnableLambda extends Runnable {
             writable: true,
             value: void 0
         });
+        assertNonTraceableFunction(fields.func);
         this.func = fields.func;
     }
     static from(func) {
@@ -1442,7 +1508,7 @@ export class RunnableLambda extends Runnable {
                         }
                         output = finalOutput;
                     }
-                    else if (isIterator(output)) {
+                    else if (isIterableIterator(output)) {
                         let finalOutput;
                         for (const chunk of consumeIteratorInContext(childConfig, output)) {
                             if (finalOutput === undefined) {
@@ -1520,7 +1586,7 @@ export class RunnableLambda extends Runnable {
                 yield chunk;
             }
         }
-        else if (isIterator(output)) {
+        else if (isIterableIterator(output)) {
             for (const chunk of consumeIteratorInContext(config, output)) {
                 yield chunk;
             }

package/dist/runnables/iter.cjs

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.consumeAsyncIterableInContext = exports.consumeIteratorInContext = exports.isAsyncIterable = exports.isIterator = void 0;
+exports.consumeAsyncIterableInContext = exports.consumeIteratorInContext = exports.isAsyncIterable = exports.isIterator = exports.isIterableIterator = void 0;
 const index_js_1 = require("../singletons/index.cjs");
-function isIterator(thing) {
+function isIterableIterator(thing) {
     return (typeof thing === "object" &&
         thing !== null &&
         typeof thing[Symbol.iterator] === "function" &&
         // avoid detecting array/set as iterator
         typeof thing.next === "function");
 }
+exports.isIterableIterator = isIterableIterator;
+const isIterator = (x) => x != null &&
+    typeof x === "object" &&
+    "next" in x &&
+    typeof x.next === "function";
 exports.isIterator = isIterator;
 function isAsyncIterable(thing) {
     return (typeof thing === "object" &&

package/dist/runnables/iter.d.ts

@@ -1,5 +1,6 @@
 import { RunnableConfig } from "./config.js";
-export declare function isIterator(thing: unknown): thing is IterableIterator<unknown>;
+export declare function isIterableIterator(thing: unknown): thing is IterableIterator<unknown>;
+export declare const isIterator: (x: unknown) => x is Iterator<unknown, any, undefined>;
 export declare function isAsyncIterable(thing: unknown): thing is AsyncIterable<unknown>;
 export declare function consumeIteratorInContext<T>(context: Partial<RunnableConfig> | undefined, iter: IterableIterator<T>): IterableIterator<T>;
 export declare function consumeAsyncIterableInContext<T>(context: Partial<RunnableConfig> | undefined, iter: AsyncIterable<T>): AsyncIterableIterator<T>;

package/dist/runnables/iter.js

@@ -1,11 +1,15 @@
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
-export function isIterator(thing) {
+export function isIterableIterator(thing) {
     return (typeof thing === "object" &&
         thing !== null &&
         typeof thing[Symbol.iterator] === "function" &&
         // avoid detecting array/set as iterator
         typeof thing.next === "function");
 }
+export const isIterator = (x) => x != null &&
+    typeof x === "object" &&
+    "next" in x &&
+    typeof x.next === "function";
 export function isAsyncIterable(thing) {
     return (typeof thing === "object" &&
         thing !== null &&