@langchain/core 0.1.52 → 0.1.54

package/dist/runnables/remote.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteRunnable = void 0;
 const base_js_1 = require("./base.cjs");
+const config_js_1 = require("./config.cjs");
 const index_js_1 = require("../documents/index.cjs");
 const prompt_values_js_1 = require("../prompt_values.cjs");
 const log_stream_js_1 = require("../tracers/log_stream.cjs");
@@ -261,7 +262,7 @@ class RemoteRunnable extends base_js_1.Runnable {
             signal: AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
-    async invoke(input, options) {
+    async _invoke(input, options, _) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const response = await this.post("/invoke", {
             input,
@@ -273,6 +274,9 @@ class RemoteRunnable extends base_js_1.Runnable {
         }
         return revive((await response.json()).output);
     }
+    async invoke(input, options) {
+        return this._callWithConfig(this._invoke, input, options);
+    }
     async _batch(inputs, options, _, batchOptions) {
         if (batchOptions?.returnExceptions) {
             throw new Error("returnExceptions is not supported for remote clients");
@@ -303,50 +307,60 @@ class RemoteRunnable extends base_js_1.Runnable {
         }
         return this._batchWithConfig(this._batch.bind(this), inputs, options, batchOptions);
     }
-    async stream(input, options) {
+    async *_streamIterator(input, options) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const response = await this.post("/stream", {
-            input,
-            config: removeCallbacks(config),
-            kwargs,
-        });
-        if (!response.ok) {
-            const json = await response.json();
-            const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            error.response = response;
-            throw error;
-        }
-        const { body } = response;
-        if (!body) {
-            throw new Error("Could not begin remote stream. Please check the given URL and try again.");
-        }
-        const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
-        async function* wrapper() {
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        let finalOutput;
+        let finalOutputSupported = true;
+        try {
+            const response = await this.post("/stream", {
+                input,
+                config: removeCallbacks(config),
+                kwargs,
+            });
+            if (!response.ok) {
+                const json = await response.json();
+                const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                error.response = response;
+                throw error;
+            }
+            const { body } = response;
+            if (!body) {
+                throw new Error("Could not begin remote stream. Please check the given URL and try again.");
+            }
+            const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
             for await (const chunk of runnableStream) {
-                yield deserialize(chunk);
+                const deserializedChunk = deserialize(chunk);
+                yield deserializedChunk;
+                if (finalOutputSupported) {
+                    if (finalOutput === undefined) {
+                        finalOutput = deserializedChunk;
+                    }
+                    else {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            finalOutput = (0, stream_js_1.concat)(finalOutput, deserializedChunk);
+                        }
+                        catch {
+                            finalOutput = undefined;
+                            finalOutputSupported = false;
+                        }
+                    }
+                }
             }
         }
-        return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrapper());
+        catch (err) {
+            await runManager?.handleChainError(err);
+            throw err;
+        }
+        await runManager?.handleChainEnd(finalOutput ?? {});
     }
     async *streamLog(input, options, streamOptions) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const stream = new log_stream_js_1.LogStreamCallbackHandler({
-            ...streamOptions,
-            autoClose: false,
-        });
-        const { callbacks } = config;
-        if (callbacks === undefined) {
-            config.callbacks = [stream];
-        }
-        else if (Array.isArray(callbacks)) {
-            config.callbacks = callbacks.concat([stream]);
-        }
-        else {
-            const copiedCallbacks = callbacks.copy();
-            copiedCallbacks.inheritableHandlers.push(stream);
-            config.callbacks = copiedCallbacks;
-        }
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         // The type is in camelCase but the API only accepts snake_case.
         const camelCaseStreamOptions = {
             include_names: streamOptions?.includeNames,
@@ -356,31 +370,48 @@ class RemoteRunnable extends base_js_1.Runnable {
             exclude_types: streamOptions?.excludeTypes,
             exclude_tags: streamOptions?.excludeTags,
         };
-        const response = await this.post("/stream_log", {
-            input,
-            config: removeCallbacks(config),
-            kwargs,
-            ...camelCaseStreamOptions,
-            diff: false,
-        });
-        const { body, ok } = response;
-        if (!ok) {
-            throw new Error(`${response.status} Error: ${await response.text()}`);
-        }
-        if (!body) {
-            throw new Error("Could not begin remote stream log. Please check the given URL and try again.");
+        let runLog;
+        try {
+            const response = await this.post("/stream_log", {
+                input,
+                config: removeCallbacks(config),
+                kwargs,
+                ...camelCaseStreamOptions,
+                diff: false,
+            });
+            const { body, ok } = response;
+            if (!ok) {
+                throw new Error(`${response.status} Error: ${await response.text()}`);
+            }
+            if (!body) {
+                throw new Error("Could not begin remote stream log. Please check the given URL and try again.");
+            }
+            const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
+            for await (const log of runnableStream) {
+                const chunk = revive(JSON.parse(log));
+                const logPatch = new log_stream_js_1.RunLogPatch({ ops: chunk.ops });
+                yield logPatch;
+                if (runLog === undefined) {
+                    runLog = log_stream_js_1.RunLog.fromRunLogPatch(logPatch);
+                }
+                else {
+                    runLog = runLog.concat(logPatch);
+                }
+            }
         }
-        const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
-        for await (const log of runnableStream) {
-            const chunk = revive(JSON.parse(log));
-            yield new log_stream_js_1.RunLogPatch({ ops: chunk.ops });
+        catch (err) {
+            await runManager?.handleChainError(err);
+            throw err;
         }
+        await runManager?.handleChainEnd(runLog?.state.final_output);
     }
     async *streamEvents(input, options, streamOptions) {
         if (options?.version !== "v1") {
             throw new Error(`Only version "v1" of the events schema is currently supported.`);
         }
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         // The type is in camelCase but the API only accepts snake_case.
         const camelCaseStreamOptions = {
             include_names: streamOptions?.includeNames,
@@ -390,32 +421,42 @@ class RemoteRunnable extends base_js_1.Runnable {
             exclude_types: streamOptions?.excludeTypes,
             exclude_tags: streamOptions?.excludeTags,
         };
-        const response = await this.post("/stream_events", {
-            input,
-            config: removeCallbacks(config),
-            kwargs,
-            ...camelCaseStreamOptions,
-            diff: false,
-        });
-        const { body, ok } = response;
-        if (!ok) {
-            throw new Error(`${response.status} Error: ${await response.text()}`);
-        }
-        if (!body) {
-            throw new Error("Could not begin remote stream events. Please check the given URL and try again.");
+        const events = [];
+        try {
+            const response = await this.post("/stream_events", {
+                input,
+                config: removeCallbacks(config),
+                kwargs,
+                ...camelCaseStreamOptions,
+                diff: false,
+            });
+            const { body, ok } = response;
+            if (!ok) {
+                throw new Error(`${response.status} Error: ${await response.text()}`);
+            }
+            if (!body) {
+                throw new Error("Could not begin remote stream events. Please check the given URL and try again.");
+            }
+            const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
+            for await (const log of runnableStream) {
+                const chunk = revive(JSON.parse(log));
+                const event = {
+                    event: chunk.event,
+                    name: chunk.name,
+                    run_id: chunk.run_id,
+                    tags: chunk.tags,
+                    metadata: chunk.metadata,
+                    data: chunk.data,
+                };
+                yield event;
+                events.push(event);
+            }
         }
-        const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
-        for await (const log of runnableStream) {
-            const chunk = revive(JSON.parse(log));
-            yield {
-                event: chunk.event,
-                name: chunk.name,
-                run_id: chunk.run_id,
-                tags: chunk.tags,
-                metadata: chunk.metadata,
-                data: chunk.data,
-            };
+        catch (err) {
+            await runManager?.handleChainError(err);
+            throw err;
         }
+        await runManager?.handleChainEnd(events);
     }
 }
 exports.RemoteRunnable = RemoteRunnable;

package/dist/runnables/remote.d.ts

@@ -1,8 +1,7 @@
 import { Runnable, RunnableBatchOptions } from "./base.js";
-import type { RunnableConfig } from "./config.js";
+import { type RunnableConfig } from "./config.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 import { RunLogPatch, type LogStreamCallbackHandlerInput, type StreamEvent } from "../tracers/log_stream.js";
-import { IterableReadableStream } from "../utils/stream.js";
 type RemoteRunnableOptions = {
     timeout?: number;
     headers?: Record<string, unknown>;
@@ -16,6 +15,7 @@ export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends Run
         options?: RemoteRunnableOptions;
     });
     private post;
+    _invoke(input: RunInput, options?: Partial<CallOptions>, _?: CallbackManagerForChainRun): Promise<RunOutput>;
     invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
     _batch(inputs: RunInput[], options?: Partial<CallOptions>[], _?: (CallbackManagerForChainRun | undefined)[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
@@ -25,7 +25,7 @@ export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends Run
         returnExceptions: true;
     }): Promise<(RunOutput | Error)[]>;
     batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
-    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<RunOutput>>;
+    _streamIterator(input: RunInput, options?: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";

package/dist/runnables/remote.js

@@ -1,11 +1,12 @@
-import { Runnable } from "./base.js";
+import { Runnable, _coerceToDict } from "./base.js";
+import { getCallbackManagerForConfig } from "./config.js";
 import { Document } from "../documents/index.js";
 import { ChatPromptValue, StringPromptValue } from "../prompt_values.js";
-import { LogStreamCallbackHandler, RunLogPatch, } from "../tracers/log_stream.js";
+import { RunLogPatch, RunLog, } from "../tracers/log_stream.js";
 import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, isBaseMessage, } from "../messages/index.js";
 import { GenerationChunk, ChatGenerationChunk, RUN_KEY } from "../outputs.js";
 import { convertEventStreamToIterableReadableDataStream } from "../utils/event_source_parse.js";
-import { IterableReadableStream } from "../utils/stream.js";
+import { concat } from "../utils/stream.js";
 function isSuperset(set, subset) {
     for (const elem of subset) {
         if (!set.has(elem)) {
@@ -258,7 +259,7 @@ export class RemoteRunnable extends Runnable {
             signal: AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
-    async invoke(input, options) {
+    async _invoke(input, options, _) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const response = await this.post("/invoke", {
             input,
@@ -270,6 +271,9 @@ export class RemoteRunnable extends Runnable {
         }
         return revive((await response.json()).output);
     }
+    async invoke(input, options) {
+        return this._callWithConfig(this._invoke, input, options);
+    }
     async _batch(inputs, options, _, batchOptions) {
         if (batchOptions?.returnExceptions) {
             throw new Error("returnExceptions is not supported for remote clients");
@@ -300,50 +304,60 @@ export class RemoteRunnable extends Runnable {
         }
         return this._batchWithConfig(this._batch.bind(this), inputs, options, batchOptions);
     }
-    async stream(input, options) {
+    async *_streamIterator(input, options) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const response = await this.post("/stream", {
-            input,
-            config: removeCallbacks(config),
-            kwargs,
-        });
-        if (!response.ok) {
-            const json = await response.json();
-            const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            error.response = response;
-            throw error;
-        }
-        const { body } = response;
-        if (!body) {
-            throw new Error("Could not begin remote stream. Please check the given URL and try again.");
-        }
-        const runnableStream = convertEventStreamToIterableReadableDataStream(body);
-        async function* wrapper() {
+        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        let finalOutput;
+        let finalOutputSupported = true;
+        try {
+            const response = await this.post("/stream", {
+                input,
+                config: removeCallbacks(config),
+                kwargs,
+            });
+            if (!response.ok) {
+                const json = await response.json();
+                const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                error.response = response;
+                throw error;
+            }
+            const { body } = response;
+            if (!body) {
+                throw new Error("Could not begin remote stream. Please check the given URL and try again.");
+            }
+            const runnableStream = convertEventStreamToIterableReadableDataStream(body);
             for await (const chunk of runnableStream) {
-                yield deserialize(chunk);
+                const deserializedChunk = deserialize(chunk);
+                yield deserializedChunk;
+                if (finalOutputSupported) {
+                    if (finalOutput === undefined) {
+                        finalOutput = deserializedChunk;
+                    }
+                    else {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            finalOutput = concat(finalOutput, deserializedChunk);
+                        }
+                        catch {
+                            finalOutput = undefined;
+                            finalOutputSupported = false;
+                        }
+                    }
+                }
             }
         }
-        return IterableReadableStream.fromAsyncGenerator(wrapper());
+        catch (err) {
+            await runManager?.handleChainError(err);
+            throw err;
+        }
+        await runManager?.handleChainEnd(finalOutput ?? {});
     }
     async *streamLog(input, options, streamOptions) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const stream = new LogStreamCallbackHandler({
-            ...streamOptions,
-            autoClose: false,
-        });
-        const { callbacks } = config;
-        if (callbacks === undefined) {
-            config.callbacks = [stream];
-        }
-        else if (Array.isArray(callbacks)) {
-            config.callbacks = callbacks.concat([stream]);
-        }
-        else {
-            const copiedCallbacks = callbacks.copy();
-            copiedCallbacks.inheritableHandlers.push(stream);
-            config.callbacks = copiedCallbacks;
-        }
+        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         // The type is in camelCase but the API only accepts snake_case.
         const camelCaseStreamOptions = {
             include_names: streamOptions?.includeNames,
@@ -353,31 +367,48 @@ export class RemoteRunnable extends Runnable {
             exclude_types: streamOptions?.excludeTypes,
             exclude_tags: streamOptions?.excludeTags,
         };
-        const response = await this.post("/stream_log", {
-            input,
-            config: removeCallbacks(config),
-            kwargs,
-            ...camelCaseStreamOptions,
-            diff: false,
-        });
-        const { body, ok } = response;
-        if (!ok) {
-            throw new Error(`${response.status} Error: ${await response.text()}`);
-        }
-        if (!body) {
-            throw new Error("Could not begin remote stream log. Please check the given URL and try again.");
+        let runLog;
+        try {
+            const response = await this.post("/stream_log", {
+                input,
+                config: removeCallbacks(config),
+                kwargs,
+                ...camelCaseStreamOptions,
+                diff: false,
+            });
+            const { body, ok } = response;
+            if (!ok) {
+                throw new Error(`${response.status} Error: ${await response.text()}`);
+            }
+            if (!body) {
+                throw new Error("Could not begin remote stream log. Please check the given URL and try again.");
+            }
+            const runnableStream = convertEventStreamToIterableReadableDataStream(body);
+            for await (const log of runnableStream) {
+                const chunk = revive(JSON.parse(log));
+                const logPatch = new RunLogPatch({ ops: chunk.ops });
+                yield logPatch;
+                if (runLog === undefined) {
+                    runLog = RunLog.fromRunLogPatch(logPatch);
+                }
+                else {
+                    runLog = runLog.concat(logPatch);
+                }
+            }
         }
-        const runnableStream = convertEventStreamToIterableReadableDataStream(body);
-        for await (const log of runnableStream) {
-            const chunk = revive(JSON.parse(log));
-            yield new RunLogPatch({ ops: chunk.ops });
+        catch (err) {
+            await runManager?.handleChainError(err);
+            throw err;
         }
+        await runManager?.handleChainEnd(runLog?.state.final_output);
     }
     async *streamEvents(input, options, streamOptions) {
         if (options?.version !== "v1") {
             throw new Error(`Only version "v1" of the events schema is currently supported.`);
         }
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
+        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         // The type is in camelCase but the API only accepts snake_case.
         const camelCaseStreamOptions = {
             include_names: streamOptions?.includeNames,
@@ -387,31 +418,41 @@ export class RemoteRunnable extends Runnable {
             exclude_types: streamOptions?.excludeTypes,
             exclude_tags: streamOptions?.excludeTags,
         };
-        const response = await this.post("/stream_events", {
-            input,
-            config: removeCallbacks(config),
-            kwargs,
-            ...camelCaseStreamOptions,
-            diff: false,
-        });
-        const { body, ok } = response;
-        if (!ok) {
-            throw new Error(`${response.status} Error: ${await response.text()}`);
-        }
-        if (!body) {
-            throw new Error("Could not begin remote stream events. Please check the given URL and try again.");
+        const events = [];
+        try {
+            const response = await this.post("/stream_events", {
+                input,
+                config: removeCallbacks(config),
+                kwargs,
+                ...camelCaseStreamOptions,
+                diff: false,
+            });
+            const { body, ok } = response;
+            if (!ok) {
+                throw new Error(`${response.status} Error: ${await response.text()}`);
+            }
+            if (!body) {
+                throw new Error("Could not begin remote stream events. Please check the given URL and try again.");
+            }
+            const runnableStream = convertEventStreamToIterableReadableDataStream(body);
+            for await (const log of runnableStream) {
+                const chunk = revive(JSON.parse(log));
+                const event = {
+                    event: chunk.event,
+                    name: chunk.name,
+                    run_id: chunk.run_id,
+                    tags: chunk.tags,
+                    metadata: chunk.metadata,
+                    data: chunk.data,
+                };
+                yield event;
+                events.push(event);
+            }
         }
-        const runnableStream = convertEventStreamToIterableReadableDataStream(body);
-        for await (const log of runnableStream) {
-            const chunk = revive(JSON.parse(log));
-            yield {
-                event: chunk.event,
-                name: chunk.name,
-                run_id: chunk.run_id,
-                tags: chunk.tags,
-                metadata: chunk.metadata,
-                data: chunk.data,
-            };
+        catch (err) {
+            await runManager?.handleChainError(err);
+            throw err;
         }
+        await runManager?.handleChainEnd(events);
     }
 }

package/dist/tools.cjs

@@ -69,7 +69,8 @@ class StructuredTool extends base_js_1.BaseLangChain {
         }
         const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
         const callbackManager_ = await manager_js_1.CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), undefined, undefined, undefined, undefined, config.runName);
+        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
+        delete config.runId;
         let result;
         try {
             result = await this._call(parsed, runManager, config);

package/dist/tools.js

@@ -65,7 +65,8 @@ export class StructuredTool extends BaseLangChain {
         }
         const config = parseCallbackConfigArg(configArg);
         const callbackManager_ = await CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), undefined, undefined, undefined, undefined, config.runName);
+        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
+        delete config.runId;
         let result;
         try {
             result = await this._call(parsed, runManager, config);

package/dist/tracers/base.d.ts

@@ -1,5 +1,5 @@
 import { KVMap, BaseRun } from "langsmith/schemas";
-import type { ChainValues } from "../utils/types.js";
+import type { ChainValues } from "../utils/types/index.js";
 import type { AgentAction, AgentFinish } from "../agents.js";
 import type { LLMResult } from "../outputs.js";
 import type { BaseMessage } from "../messages/index.js";

package/dist/tracers/tracer_langchain_v1.d.ts

@@ -1,4 +1,4 @@
-import type { ChainValues } from "../utils/types.js";
+import type { ChainValues } from "../utils/types/index.js";
 import type { LLMResult } from "../outputs.js";
 import { BaseTracer, type RunType, type Run } from "./base.js";
 export interface BaseRunV1 {

package/dist/utils/testing/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyntheticEmbeddings = exports.FakeEmbeddings = exports.FakeTool = exports.FakeTracer = exports.FakeListChatMessageHistory = exports.FakeChatMessageHistory = exports.FakeListChatModel = exports.FakeRetriever = exports.FakeChatModel = exports.FakeStreamingLLM = exports.FakeLLM = exports.FakeRunnable = exports.FakeSplitIntoListParser = void 0;
+exports.SingleRunExtractor = exports.SyntheticEmbeddings = exports.FakeEmbeddings = exports.FakeTool = exports.FakeTracer = exports.FakeListChatMessageHistory = exports.FakeChatMessageHistory = exports.FakeListChatModel = exports.FakeRetriever = exports.FakeChatModel = exports.FakeStreamingLLM = exports.FakeLLM = exports.FakeRunnable = exports.FakeSplitIntoListParser = void 0;
 const chat_history_js_1 = require("../../chat_history.cjs");
 const document_js_1 = require("../../documents/document.cjs");
 const chat_models_js_1 = require("../../language_models/chat_models.cjs");
@@ -8,7 +8,7 @@ const llms_js_1 = require("../../language_models/llms.cjs");
 const index_js_1 = require("../../messages/index.cjs");
 const base_js_1 = require("../../output_parsers/base.cjs");
 const outputs_js_1 = require("../../outputs.cjs");
-const retrievers_js_1 = require("../../retrievers.cjs");
+const index_js_2 = require("../../retrievers/index.cjs");
 const base_js_2 = require("../../runnables/base.cjs");
 const tools_js_1 = require("../../tools.cjs");
 const base_js_3 = require("../../tracers/base.cjs");
@@ -172,7 +172,7 @@ class FakeChatModel extends chat_models_js_1.BaseChatModel {
     }
 }
 exports.FakeChatModel = FakeChatModel;
-class FakeRetriever extends retrievers_js_1.BaseRetriever {
+class FakeRetriever extends index_js_2.BaseRetriever {
     constructor(fields) {
         super();
         Object.defineProperty(this, "lc_namespace", {
@@ -518,3 +518,37 @@ class SyntheticEmbeddings extends embeddings_js_1.Embeddings {
     }
 }
 exports.SyntheticEmbeddings = SyntheticEmbeddings;
+class SingleRunExtractor extends base_js_3.BaseTracer {
+    constructor() {
+        super();
+        Object.defineProperty(this, "runPromiseResolver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "runPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The name of the callback handler. */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "single_run_extractor"
+        });
+        this.runPromise = new Promise((extract) => {
+            this.runPromiseResolver = extract;
+        });
+    }
+    async persistRun(run) {
+        this.runPromiseResolver(run);
+    }
+    async extract() {
+        return this.runPromise;
+    }
+}
+exports.SingleRunExtractor = SingleRunExtractor;