@langchain/core 1.0.0-alpha.4 → 1.0.0-alpha.5

package/dist/utils/testing/index.cjs

@@ -1,666 +1,53 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const require_ai = require('../../messages/ai.cjs');
-const require_human = require('../../messages/human.cjs');
-const require_tracers_base = require('../../tracers/base.cjs');
-const require_outputs = require('../../outputs.cjs');
-const require_utils_json_schema = require('../json_schema.cjs');
-const require_base = require('../../runnables/base.cjs');
-require('../../messages/index.cjs');
-const require_chat_history = require('../../chat_history.cjs');
-const require_embeddings = require('../../embeddings.cjs');
-const require_retrievers_index = require('../../retrievers/index.cjs');
-const require_vectorstores = require('../../vectorstores.cjs');
-const require_document = require('../../documents/document.cjs');
-const require_language_models_chat_models = require('../../language_models/chat_models.cjs');
-const require_language_models_llms = require('../../language_models/llms.cjs');
-const require_base$1 = require('../../output_parsers/base.cjs');
-const require_tools_index = require('../../tools/index.cjs');
-const require_similarities = require('../ml-distance/similarities.cjs');
+const require_chat_models = require('./chat_models.cjs');
+const require_embeddings = require('./embeddings.cjs');
+const require_llms = require('./llms.cjs');
+const require_message_history = require('./message_history.cjs');
+const require_output_parsers = require('./output_parsers.cjs');
+const require_retrievers = require('./retrievers.cjs');
+const require_runnables = require('./runnables.cjs');
+const require_tools = require('./tools.cjs');
+const require_tracers = require('./tracers.cjs');
+const require_vectorstores = require('./vectorstores.cjs');
 
 //#region src/utils/testing/index.ts
 var testing_exports = {};
 require_rolldown_runtime.__export(testing_exports, {
-	FakeChatMessageHistory: () => FakeChatMessageHistory,
-	FakeChatModel: () => FakeChatModel,
-	FakeEmbeddings: () => FakeEmbeddings,
-	FakeLLM: () => FakeLLM,
-	FakeListChatMessageHistory: () => FakeListChatMessageHistory,
-	FakeListChatModel: () => FakeListChatModel,
-	FakeRetriever: () => FakeRetriever,
-	FakeRunnable: () => FakeRunnable,
-	FakeSplitIntoListParser: () => FakeSplitIntoListParser,
-	FakeStreamingChatModel: () => FakeStreamingChatModel,
-	FakeStreamingLLM: () => FakeStreamingLLM,
-	FakeTool: () => FakeTool,
-	FakeTracer: () => FakeTracer,
-	FakeVectorStore: () => FakeVectorStore,
-	SingleRunExtractor: () => SingleRunExtractor,
-	SyntheticEmbeddings: () => SyntheticEmbeddings
+	FakeChatMessageHistory: () => require_message_history.FakeChatMessageHistory,
+	FakeChatModel: () => require_chat_models.FakeChatModel,
+	FakeEmbeddings: () => require_embeddings.FakeEmbeddings,
+	FakeLLM: () => require_llms.FakeLLM,
+	FakeListChatMessageHistory: () => require_message_history.FakeListChatMessageHistory,
+	FakeListChatModel: () => require_chat_models.FakeListChatModel,
+	FakeRetriever: () => require_retrievers.FakeRetriever,
+	FakeRunnable: () => require_runnables.FakeRunnable,
+	FakeSplitIntoListParser: () => require_output_parsers.FakeSplitIntoListParser,
+	FakeStreamingChatModel: () => require_chat_models.FakeStreamingChatModel,
+	FakeStreamingLLM: () => require_llms.FakeStreamingLLM,
+	FakeTool: () => require_tools.FakeTool,
+	FakeTracer: () => require_message_history.FakeTracer,
+	FakeVectorStore: () => require_vectorstores.FakeVectorStore,
+	SingleRunExtractor: () => require_tracers.SingleRunExtractor,
+	SyntheticEmbeddings: () => require_embeddings.SyntheticEmbeddings
 });
-/**
-* Parser for comma-separated values. It splits the input text by commas
-* and trims the resulting values.
-*/
-var FakeSplitIntoListParser = class extends require_base$1.BaseOutputParser {
-	lc_namespace = ["tests", "fake"];
-	getFormatInstructions() {
-		return "";
-	}
-	async parse(text) {
-		return text.split(",").map((value) => value.trim());
-	}
-};
-var FakeRunnable = class extends require_base.Runnable {
-	lc_namespace = ["tests", "fake"];
-	returnOptions;
-	constructor(fields) {
-		super(fields);
-		this.returnOptions = fields.returnOptions;
-	}
-	async invoke(input, options) {
-		if (this.returnOptions) return options ?? {};
-		return { input };
-	}
-};
-var FakeLLM = class extends require_language_models_llms.LLM {
-	response;
-	thrownErrorString;
-	constructor(fields) {
-		super(fields);
-		this.response = fields.response;
-		this.thrownErrorString = fields.thrownErrorString;
-	}
-	_llmType() {
-		return "fake";
-	}
-	async _call(prompt, _options, runManager) {
-		if (this.thrownErrorString) throw new Error(this.thrownErrorString);
-		const response = this.response ?? prompt;
-		await runManager?.handleLLMNewToken(response);
-		return response;
-	}
-};
-var FakeStreamingLLM = class extends require_language_models_llms.LLM {
-	sleep = 50;
-	responses;
-	thrownErrorString;
-	constructor(fields) {
-		super(fields);
-		this.sleep = fields.sleep ?? this.sleep;
-		this.responses = fields.responses;
-		this.thrownErrorString = fields.thrownErrorString;
-	}
-	_llmType() {
-		return "fake";
-	}
-	async _call(prompt) {
-		if (this.thrownErrorString) throw new Error(this.thrownErrorString);
-		const response = this.responses?.[0];
-		this.responses = this.responses?.slice(1);
-		return response ?? prompt;
-	}
-	async *_streamResponseChunks(input, _options, runManager) {
-		if (this.thrownErrorString) throw new Error(this.thrownErrorString);
-		const response = this.responses?.[0];
-		this.responses = this.responses?.slice(1);
-		for (const c of response ?? input) {
-			await new Promise((resolve) => setTimeout(resolve, this.sleep));
-			yield {
-				text: c,
-				generationInfo: {}
-			};
-			await runManager?.handleLLMNewToken(c);
-		}
-	}
-};
-var FakeChatModel = class extends require_language_models_chat_models.BaseChatModel {
-	_combineLLMOutput() {
-		return [];
-	}
-	_llmType() {
-		return "fake";
-	}
-	async _generate(messages, options, runManager) {
-		if (options?.stop?.length) return { generations: [{
-			message: new require_ai.AIMessage(options.stop[0]),
-			text: options.stop[0]
-		}] };
-		const text = messages.map((m) => {
-			if (typeof m.content === "string") return m.content;
-			return JSON.stringify(m.content, null, 2);
-		}).join("\n");
-		await runManager?.handleLLMNewToken(text);
-		return {
-			generations: [{
-				message: new require_ai.AIMessage(text),
-				text
-			}],
-			llmOutput: {}
-		};
-	}
-};
-var FakeStreamingChatModel = class FakeStreamingChatModel extends require_language_models_chat_models.BaseChatModel {
-	sleep = 50;
-	responses = [];
-	chunks = [];
-	toolStyle = "openai";
-	thrownErrorString;
-	tools = [];
-	constructor({ sleep = 50, responses = [], chunks = [], toolStyle = "openai", thrownErrorString,...rest }) {
-		super(rest);
-		this.sleep = sleep;
-		this.responses = responses;
-		this.chunks = chunks;
-		this.toolStyle = toolStyle;
-		this.thrownErrorString = thrownErrorString;
-	}
-	_llmType() {
-		return "fake";
-	}
-	bindTools(tools) {
-		const merged = [...this.tools, ...tools];
-		const toolDicts = merged.map((t) => {
-			switch (this.toolStyle) {
-				case "openai": return {
-					type: "function",
-					function: {
-						name: t.name,
-						description: t.description,
-						parameters: require_utils_json_schema.toJsonSchema(t.schema)
-					}
-				};
-				case "anthropic": return {
-					name: t.name,
-					description: t.description,
-					input_schema: require_utils_json_schema.toJsonSchema(t.schema)
-				};
-				case "bedrock": return { toolSpec: {
-					name: t.name,
-					description: t.description,
-					inputSchema: require_utils_json_schema.toJsonSchema(t.schema)
-				} };
-				case "google": return {
-					name: t.name,
-					description: t.description,
-					parameters: require_utils_json_schema.toJsonSchema(t.schema)
-				};
-				default: throw new Error(`Unsupported tool style: ${this.toolStyle}`);
-			}
-		});
-		const wrapped = this.toolStyle === "google" ? [{ functionDeclarations: toolDicts }] : toolDicts;
-		const next = new FakeStreamingChatModel({
-			sleep: this.sleep,
-			responses: this.responses,
-			chunks: this.chunks,
-			toolStyle: this.toolStyle,
-			thrownErrorString: this.thrownErrorString
-		});
-		next.tools = merged;
-		return next.withConfig({ tools: wrapped });
-	}
-	async _generate(messages, _options, _runManager) {
-		if (this.thrownErrorString) throw new Error(this.thrownErrorString);
-		const content = this.responses?.[0]?.content ?? messages[0].content ?? "";
-		const generation = { generations: [{
-			text: "",
-			message: new require_ai.AIMessage({
-				content,
-				tool_calls: this.chunks?.[0]?.tool_calls
-			})
-		}] };
-		return generation;
-	}
-	async *_streamResponseChunks(_messages, _options, runManager) {
-		if (this.thrownErrorString) throw new Error(this.thrownErrorString);
-		if (this.chunks?.length) {
-			for (const msgChunk of this.chunks) {
-				const cg = new require_outputs.ChatGenerationChunk({
-					message: new require_ai.AIMessageChunk({
-						content: msgChunk.content,
-						tool_calls: msgChunk.tool_calls,
-						additional_kwargs: msgChunk.additional_kwargs ?? {}
-					}),
-					text: msgChunk.content?.toString() ?? ""
-				});
-				yield cg;
-				await runManager?.handleLLMNewToken(msgChunk.content, void 0, void 0, void 0, void 0, { chunk: cg });
-			}
-			return;
-		}
-		const fallback = this.responses?.[0] ?? new require_ai.AIMessage(typeof _messages[0].content === "string" ? _messages[0].content : "");
-		const text = typeof fallback.content === "string" ? fallback.content : "";
-		for (const ch of text) {
-			await new Promise((r) => setTimeout(r, this.sleep));
-			const cg = new require_outputs.ChatGenerationChunk({
-				message: new require_ai.AIMessageChunk({ content: ch }),
-				text: ch
-			});
-			yield cg;
-			await runManager?.handleLLMNewToken(ch, void 0, void 0, void 0, void 0, { chunk: cg });
-		}
-	}
-};
-var FakeRetriever = class extends require_retrievers_index.BaseRetriever {
-	lc_namespace = ["test", "fake"];
-	output = [new require_document.Document({ pageContent: "foo" }), new require_document.Document({ pageContent: "bar" })];
-	constructor(fields) {
-		super();
-		this.output = fields?.output ?? this.output;
-	}
-	async _getRelevantDocuments(_query) {
-		return this.output;
-	}
-};
-/**
-* A fake Chat Model that returns a predefined list of responses. It can be used
-* for testing purposes.
-* @example
-* ```typescript
-* const chat = new FakeListChatModel({
-*   responses: ["I'll callback later.", "You 'console' them!"]
-* });
-*
-* const firstMessage = new HumanMessage("You want to hear a JavaScript joke?");
-* const secondMessage = new HumanMessage("How do you cheer up a JavaScript developer?");
-*
-* // Call the chat model with a message and log the response
-* const firstResponse = await chat.call([firstMessage]);
-* console.log({ firstResponse });
-*
-* const secondResponse = await chat.call([secondMessage]);
-* console.log({ secondResponse });
-* ```
-*/
-var FakeListChatModel = class extends require_language_models_chat_models.BaseChatModel {
-	static lc_name() {
-		return "FakeListChatModel";
-	}
-	lc_serializable = true;
-	responses;
-	i = 0;
-	sleep;
-	emitCustomEvent = false;
-	constructor(params) {
-		super(params);
-		const { responses, sleep, emitCustomEvent } = params;
-		this.responses = responses;
-		this.sleep = sleep;
-		this.emitCustomEvent = emitCustomEvent ?? this.emitCustomEvent;
-	}
-	_combineLLMOutput() {
-		return [];
-	}
-	_llmType() {
-		return "fake-list";
-	}
-	async _generate(_messages, options, runManager) {
-		await this._sleepIfRequested();
-		if (options?.thrownErrorString) throw new Error(options.thrownErrorString);
-		if (this.emitCustomEvent) await runManager?.handleCustomEvent("some_test_event", { someval: true });
-		if (options?.stop?.length) return { generations: [this._formatGeneration(options.stop[0])] };
-		else {
-			const response = this._currentResponse();
-			this._incrementResponse();
-			return {
-				generations: [this._formatGeneration(response)],
-				llmOutput: {}
-			};
-		}
-	}
-	_formatGeneration(text) {
-		return {
-			message: new require_ai.AIMessage(text),
-			text
-		};
-	}
-	async *_streamResponseChunks(_messages, options, runManager) {
-		const response = this._currentResponse();
-		this._incrementResponse();
-		if (this.emitCustomEvent) await runManager?.handleCustomEvent("some_test_event", { someval: true });
-		for await (const text of response) {
-			await this._sleepIfRequested();
-			if (options?.thrownErrorString) throw new Error(options.thrownErrorString);
-			const chunk = this._createResponseChunk(text);
-			yield chunk;
-			runManager?.handleLLMNewToken(text);
-		}
-	}
-	async _sleepIfRequested() {
-		if (this.sleep !== void 0) await this._sleep();
-	}
-	async _sleep() {
-		return new Promise((resolve) => {
-			setTimeout(() => resolve(), this.sleep);
-		});
-	}
-	_createResponseChunk(text) {
-		return new require_outputs.ChatGenerationChunk({
-			message: new require_ai.AIMessageChunk({ content: text }),
-			text
-		});
-	}
-	_currentResponse() {
-		return this.responses[this.i];
-	}
-	_incrementResponse() {
-		if (this.i < this.responses.length - 1) this.i += 1;
-		else this.i = 0;
-	}
-	withStructuredOutput(_params, _config) {
-		return require_base.RunnableLambda.from(async (input) => {
-			const message = await this.invoke(input);
-			if (message.tool_calls?.[0]?.args) return message.tool_calls[0].args;
-			if (typeof message.content === "string") return JSON.parse(message.content);
-			throw new Error("No structured output found");
-		});
-	}
-};
-var FakeChatMessageHistory = class extends require_chat_history.BaseChatMessageHistory {
-	lc_namespace = [
-		"langchain_core",
-		"message",
-		"fake"
-	];
-	messages = [];
-	constructor() {
-		super();
-	}
-	async getMessages() {
-		return this.messages;
-	}
-	async addMessage(message) {
-		this.messages.push(message);
-	}
-	async addUserMessage(message) {
-		this.messages.push(new require_human.HumanMessage(message));
-	}
-	async addAIChatMessage(message) {
-		this.messages.push(new require_ai.AIMessage(message));
-	}
-	async clear() {
-		this.messages = [];
-	}
-};
-var FakeListChatMessageHistory = class extends require_chat_history.BaseListChatMessageHistory {
-	lc_namespace = [
-		"langchain_core",
-		"message",
-		"fake"
-	];
-	messages = [];
-	constructor() {
-		super();
-	}
-	async addMessage(message) {
-		this.messages.push(message);
-	}
-	async getMessages() {
-		return this.messages;
-	}
-};
-var FakeTracer = class extends require_tracers_base.BaseTracer {
-	name = "fake_tracer";
-	runs = [];
-	constructor() {
-		super();
-	}
-	persistRun(run) {
-		this.runs.push(run);
-		return Promise.resolve();
-	}
-};
-var FakeTool = class extends require_tools_index.StructuredTool {
-	name;
-	description;
-	schema;
-	constructor(fields) {
-		super(fields);
-		this.name = fields.name;
-		this.description = fields.description;
-		this.schema = fields.schema;
-	}
-	async _call(arg, _runManager) {
-		return JSON.stringify(arg);
-	}
-};
-/**
-* A class that provides fake embeddings by overriding the embedDocuments
-* and embedQuery methods to return fixed values.
-*/
-var FakeEmbeddings = class extends require_embeddings.Embeddings {
-	constructor(params) {
-		super(params ?? {});
-	}
-	/**
-	* Generates fixed embeddings for a list of documents.
-	* @param documents List of documents to generate embeddings for.
-	* @returns A promise that resolves with a list of fixed embeddings for each document.
-	*/
-	embedDocuments(documents) {
-		return Promise.resolve(documents.map(() => [
-			.1,
-			.2,
-			.3,
-			.4
-		]));
-	}
-	/**
-	* Generates a fixed embedding for a query.
-	* @param _ The query to generate an embedding for.
-	* @returns A promise that resolves with a fixed embedding for the query.
-	*/
-	embedQuery(_) {
-		return Promise.resolve([
-			.1,
-			.2,
-			.3,
-			.4
-		]);
-	}
-};
-/**
-* A class that provides synthetic embeddings by overriding the
-* embedDocuments and embedQuery methods to generate embeddings based on
-* the input documents. The embeddings are generated by converting each
-* document into chunks, calculating a numerical value for each chunk, and
-* returning an array of these values as the embedding.
-*/
-var SyntheticEmbeddings = class extends require_embeddings.Embeddings {
-	vectorSize;
-	constructor(params) {
-		super(params ?? {});
-		this.vectorSize = params?.vectorSize ?? 4;
-	}
-	/**
-	* Generates synthetic embeddings for a list of documents.
-	* @param documents List of documents to generate embeddings for.
-	* @returns A promise that resolves with a list of synthetic embeddings for each document.
-	*/
-	async embedDocuments(documents) {
-		return Promise.all(documents.map((doc) => this.embedQuery(doc)));
-	}
-	/**
-	* Generates a synthetic embedding for a document. The document is
-	* converted into chunks, a numerical value is calculated for each chunk,
-	* and an array of these values is returned as the embedding.
-	* @param document The document to generate an embedding for.
-	* @returns A promise that resolves with a synthetic embedding for the document.
-	*/
-	async embedQuery(document) {
-		let doc = document;
-		doc = doc.toLowerCase().replaceAll(/[^a-z ]/g, "");
-		const padMod = doc.length % this.vectorSize;
-		const padGapSize = padMod === 0 ? 0 : this.vectorSize - padMod;
-		const padSize = doc.length + padGapSize;
-		doc = doc.padEnd(padSize, " ");
-		const chunkSize = doc.length / this.vectorSize;
-		const docChunk = [];
-		for (let co = 0; co < doc.length; co += chunkSize) docChunk.push(doc.slice(co, co + chunkSize));
-		const ret = docChunk.map((s) => {
-			let sum = 0;
-			for (let co = 0; co < s.length; co += 1) sum += s === " " ? 0 : s.charCodeAt(co);
-			const ret$1 = sum % 26 / 26;
-			return ret$1;
-		});
-		return ret;
-	}
-};
-var SingleRunExtractor = class extends require_tracers_base.BaseTracer {
-	runPromiseResolver;
-	runPromise;
-	/** The name of the callback handler. */
-	name = "single_run_extractor";
-	constructor() {
-		super();
-		this.runPromise = new Promise((extract) => {
-			this.runPromiseResolver = extract;
-		});
-	}
-	async persistRun(run) {
-		this.runPromiseResolver(run);
-	}
-	async extract() {
-		return this.runPromise;
-	}
-};
-/**
-* Class that extends `VectorStore` to store vectors in memory. Provides
-* methods for adding documents, performing similarity searches, and
-* creating instances from texts, documents, or an existing index.
-*/
-var FakeVectorStore = class FakeVectorStore extends require_vectorstores.VectorStore {
-	memoryVectors = [];
-	similarity;
-	_vectorstoreType() {
-		return "memory";
-	}
-	constructor(embeddings, { similarity,...rest } = {}) {
-		super(embeddings, rest);
-		this.similarity = similarity ?? require_similarities.cosine;
-	}
-	/**
-	* Method to add documents to the memory vector store. It extracts the
-	* text from each document, generates embeddings for them, and adds the
-	* resulting vectors to the store.
-	* @param documents Array of `Document` instances to be added to the store.
-	* @returns Promise that resolves when all documents have been added.
-	*/
-	async addDocuments(documents) {
-		const texts = documents.map(({ pageContent }) => pageContent);
-		return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
-	}
-	/**
-	* Method to add vectors to the memory vector store. It creates
-	* `MemoryVector` instances for each vector and document pair and adds
-	* them to the store.
-	* @param vectors Array of vectors to be added to the store.
-	* @param documents Array of `Document` instances corresponding to the vectors.
-	* @returns Promise that resolves when all vectors have been added.
-	*/
-	async addVectors(vectors, documents) {
-		const memoryVectors = vectors.map((embedding, idx) => ({
-			content: documents[idx].pageContent,
-			embedding,
-			metadata: documents[idx].metadata
-		}));
-		this.memoryVectors = this.memoryVectors.concat(memoryVectors);
-	}
-	/**
-	* Method to perform a similarity search in the memory vector store. It
-	* calculates the similarity between the query vector and each vector in
-	* the store, sorts the results by similarity, and returns the top `k`
-	* results along with their scores.
-	* @param query Query vector to compare against the vectors in the store.
-	* @param k Number of top results to return.
-	* @param filter Optional filter function to apply to the vectors before performing the search.
-	* @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
-	*/
-	async similaritySearchVectorWithScore(query, k, filter) {
-		const filterFunction = (memoryVector) => {
-			if (!filter) return true;
-			const doc = new require_document.Document({
-				metadata: memoryVector.metadata,
-				pageContent: memoryVector.content
-			});
-			return filter(doc);
-		};
-		const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);
-		const searches = filteredMemoryVectors.map((vector, index) => ({
-			similarity: this.similarity(query, vector.embedding),
-			index
-		})).sort((a, b) => a.similarity > b.similarity ? -1 : 0).slice(0, k);
-		const result = searches.map((search) => [new require_document.Document({
-			metadata: filteredMemoryVectors[search.index].metadata,
-			pageContent: filteredMemoryVectors[search.index].content
-		}), search.similarity]);
-		return result;
-	}
-	/**
-	* Static method to create a `FakeVectorStore` instance from an array of
-	* texts. It creates a `Document` for each text and metadata pair, and
-	* adds them to the store.
-	* @param texts Array of texts to be added to the store.
-	* @param metadatas Array or single object of metadata corresponding to the texts.
-	* @param embeddings `Embeddings` instance used to generate embeddings for the texts.
-	* @param dbConfig Optional `FakeVectorStoreArgs` to configure the `FakeVectorStore` instance.
-	* @returns Promise that resolves with a new `FakeVectorStore` instance.
-	*/
-	static async fromTexts(texts, metadatas, embeddings, dbConfig) {
-		const docs = [];
-		for (let i = 0; i < texts.length; i += 1) {
-			const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
-			const newDoc = new require_document.Document({
-				pageContent: texts[i],
-				metadata
-			});
-			docs.push(newDoc);
-		}
-		return FakeVectorStore.fromDocuments(docs, embeddings, dbConfig);
-	}
-	/**
-	* Static method to create a `FakeVectorStore` instance from an array of
-	* `Document` instances. It adds the documents to the store.
-	* @param docs Array of `Document` instances to be added to the store.
-	* @param embeddings `Embeddings` instance used to generate embeddings for the documents.
-	* @param dbConfig Optional `FakeVectorStoreArgs` to configure the `FakeVectorStore` instance.
-	* @returns Promise that resolves with a new `FakeVectorStore` instance.
-	*/
-	static async fromDocuments(docs, embeddings, dbConfig) {
-		const instance = new this(embeddings, dbConfig);
-		await instance.addDocuments(docs);
-		return instance;
-	}
-	/**
-	* Static method to create a `FakeVectorStore` instance from an existing
-	* index. It creates a new `FakeVectorStore` instance without adding any
-	* documents or vectors.
-	* @param embeddings `Embeddings` instance used to generate embeddings for the documents.
-	* @param dbConfig Optional `FakeVectorStoreArgs` to configure the `FakeVectorStore` instance.
-	* @returns Promise that resolves with a new `FakeVectorStore` instance.
-	*/
-	static async fromExistingIndex(embeddings, dbConfig) {
-		const instance = new this(embeddings, dbConfig);
-		return instance;
-	}
-};
 
 //#endregion
-exports.FakeChatMessageHistory = FakeChatMessageHistory;
-exports.FakeChatModel = FakeChatModel;
-exports.FakeEmbeddings = FakeEmbeddings;
-exports.FakeLLM = FakeLLM;
-exports.FakeListChatMessageHistory = FakeListChatMessageHistory;
-exports.FakeListChatModel = FakeListChatModel;
-exports.FakeRetriever = FakeRetriever;
-exports.FakeRunnable = FakeRunnable;
-exports.FakeSplitIntoListParser = FakeSplitIntoListParser;
-exports.FakeStreamingChatModel = FakeStreamingChatModel;
-exports.FakeStreamingLLM = FakeStreamingLLM;
-exports.FakeTool = FakeTool;
-exports.FakeTracer = FakeTracer;
-exports.FakeVectorStore = FakeVectorStore;
-exports.SingleRunExtractor = SingleRunExtractor;
-exports.SyntheticEmbeddings = SyntheticEmbeddings;
+exports.FakeChatMessageHistory = require_message_history.FakeChatMessageHistory;
+exports.FakeChatModel = require_chat_models.FakeChatModel;
+exports.FakeEmbeddings = require_embeddings.FakeEmbeddings;
+exports.FakeLLM = require_llms.FakeLLM;
+exports.FakeListChatMessageHistory = require_message_history.FakeListChatMessageHistory;
+exports.FakeListChatModel = require_chat_models.FakeListChatModel;
+exports.FakeRetriever = require_retrievers.FakeRetriever;
+exports.FakeRunnable = require_runnables.FakeRunnable;
+exports.FakeSplitIntoListParser = require_output_parsers.FakeSplitIntoListParser;
+exports.FakeStreamingChatModel = require_chat_models.FakeStreamingChatModel;
+exports.FakeStreamingLLM = require_llms.FakeStreamingLLM;
+exports.FakeTool = require_tools.FakeTool;
+exports.FakeTracer = require_message_history.FakeTracer;
+exports.FakeVectorStore = require_vectorstores.FakeVectorStore;
+exports.SingleRunExtractor = require_tracers.SingleRunExtractor;
+exports.SyntheticEmbeddings = require_embeddings.SyntheticEmbeddings;
 Object.defineProperty(exports, 'testing_exports', {
   enumerable: true,
   get: function () {