@nocobase/plugin-ai 1.6.0-beta.17

package/dist/node_modules/@langchain/core/dist/language_models/llms.js

@@ -0,0 +1,374 @@
+import { AIMessage, getBufferString, } from "../messages/index.js";
+import { RUN_KEY, GenerationChunk, } from "../outputs.js";
+import { CallbackManager, } from "../callbacks/manager.js";
+import { BaseLanguageModel, } from "./base.js";
+import { concat } from "../utils/stream.js";
+import { callbackHandlerPrefersStreaming } from "../callbacks/base.js";
+/**
+ * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
+ */
+export class BaseLLM extends BaseLanguageModel {
+    constructor({ concurrency, ...rest }) {
+        super(concurrency ? { maxConcurrency: concurrency, ...rest } : rest);
+        // Only ever instantiated in main LangChain
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "llms", this._llmType()]
+        });
+    }
+    /**
+     * This method takes an input and options, and returns a string. It
+     * converts the input to a prompt value and generates a result based on
+     * the prompt.
+     * @param input Input for the LLM.
+     * @param options Options for the LLM call.
+     * @returns A string result based on the prompt.
+     */
+    async invoke(input, options) {
+        const promptValue = BaseLLM._convertInputToPromptValue(input);
+        const result = await this.generatePrompt([promptValue], options, options?.callbacks);
+        return result.generations[0][0].text;
+    }
+    // eslint-disable-next-line require-yield
+    async *_streamResponseChunks(_input, _options, _runManager) {
+        throw new Error("Not implemented.");
+    }
+    _separateRunnableConfigFromCallOptionsCompat(options) {
+        // For backwards compat, keep `signal` in both runnableConfig and callOptions
+        const [runnableConfig, callOptions] = super._separateRunnableConfigFromCallOptions(options);
+        callOptions.signal = runnableConfig.signal;
+        return [runnableConfig, callOptions];
+    }
+    async *_streamIterator(input, options) {
+        // Subclass check required to avoid double callbacks with default implementation
+        if (this._streamResponseChunks === BaseLLM.prototype._streamResponseChunks) {
+            yield this.invoke(input, options);
+        }
+        else {
+            const prompt = BaseLLM._convertInputToPromptValue(input);
+            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
+            const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+            const extra = {
+                options: callOptions,
+                invocation_params: this?.invocationParams(callOptions),
+                batch_size: 1,
+            };
+            const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], runnableConfig.runId, undefined, extra, undefined, undefined, runnableConfig.runName);
+            let generation = new GenerationChunk({
+                text: "",
+            });
+            try {
+                for await (const chunk of this._streamResponseChunks(prompt.toString(), callOptions, runManagers?.[0])) {
+                    if (!generation) {
+                        generation = chunk;
+                    }
+                    else {
+                        generation = generation.concat(chunk);
+                    }
+                    if (typeof chunk.text === "string") {
+                        yield chunk.text;
+                    }
+                }
+            }
+            catch (err) {
+                await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
+                throw err;
+            }
+            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMEnd({
+                generations: [[generation]],
+            })));
+        }
+    }
+    /**
+     * This method takes prompt values, options, and callbacks, and generates
+     * a result based on the prompts.
+     * @param promptValues Prompt values for the LLM.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns An LLMResult based on the prompts.
+     */
+    async generatePrompt(promptValues, options, callbacks) {
+        const prompts = promptValues.map((promptValue) => promptValue.toString());
+        return this.generate(prompts, options, callbacks);
+    }
+    /**
+     * Get the parameters used to invoke the model
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    invocationParams(_options) {
+        return {};
+    }
+    _flattenLLMResult(llmResult) {
+        const llmResults = [];
+        for (let i = 0; i < llmResult.generations.length; i += 1) {
+            const genList = llmResult.generations[i];
+            if (i === 0) {
+                llmResults.push({
+                    generations: [genList],
+                    llmOutput: llmResult.llmOutput,
+                });
+            }
+            else {
+                const llmOutput = llmResult.llmOutput
+                    ? { ...llmResult.llmOutput, tokenUsage: {} }
+                    : undefined;
+                llmResults.push({
+                    generations: [genList],
+                    llmOutput,
+                });
+            }
+        }
+        return llmResults;
+    }
+    /** @ignore */
+    async _generateUncached(prompts, parsedOptions, handledOptions, startedRunManagers) {
+        let runManagers;
+        if (startedRunManagers !== undefined &&
+            startedRunManagers.length === prompts.length) {
+            runManagers = startedRunManagers;
+        }
+        else {
+            const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+            const extra = {
+                options: parsedOptions,
+                invocation_params: this?.invocationParams(parsedOptions),
+                batch_size: prompts.length,
+            };
+            runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
+        }
+        // Even if stream is not explicitly called, check if model is implicitly
+        // called from streamEvents() or streamLog() to get all streamed events.
+        // Bail out if _streamResponseChunks not overridden
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find(callbackHandlerPrefersStreaming);
+        let output;
+        if (hasStreamingHandler &&
+            prompts.length === 1 &&
+            this._streamResponseChunks !== BaseLLM.prototype._streamResponseChunks) {
+            try {
+                const stream = await this._streamResponseChunks(prompts[0], parsedOptions, runManagers?.[0]);
+                let aggregated;
+                for await (const chunk of stream) {
+                    if (aggregated === undefined) {
+                        aggregated = chunk;
+                    }
+                    else {
+                        aggregated = concat(aggregated, chunk);
+                    }
+                }
+                if (aggregated === undefined) {
+                    throw new Error("Received empty response from chat model call.");
+                }
+                output = { generations: [[aggregated]], llmOutput: {} };
+                await runManagers?.[0].handleLLMEnd(output);
+            }
+            catch (e) {
+                await runManagers?.[0].handleLLMError(e);
+                throw e;
+            }
+        }
+        else {
+            try {
+                output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
+            }
+            catch (err) {
+                await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
+                throw err;
+            }
+            const flattenedOutputs = this._flattenLLMResult(output);
+            await Promise.all((runManagers ?? []).map((runManager, i) => runManager?.handleLLMEnd(flattenedOutputs[i])));
+        }
+        const runIds = runManagers?.map((manager) => manager.runId) || undefined;
+        // This defines RUN_KEY as a non-enumerable property on the output object
+        // so that it is not serialized when the output is stringified, and so that
+        // it isnt included when listing the keys of the output object.
+        Object.defineProperty(output, RUN_KEY, {
+            value: runIds ? { runIds } : undefined,
+            configurable: true,
+        });
+        return output;
+    }
+    async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId, }) {
+        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const extra = {
+            options: parsedOptions,
+            invocation_params: this?.invocationParams(parsedOptions),
+            batch_size: prompts.length,
+        };
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, runId, undefined, extra, undefined, undefined, handledOptions?.runName);
+        // generate results
+        const missingPromptIndices = [];
+        const results = await Promise.allSettled(prompts.map(async (prompt, index) => {
+            const result = await cache.lookup(prompt, llmStringKey);
+            if (result == null) {
+                missingPromptIndices.push(index);
+            }
+            return result;
+        }));
+        // Map run managers to the results before filtering out null results
+        // Null results are just absent from the cache.
+        const cachedResults = results
+            .map((result, index) => ({ result, runManager: runManagers?.[index] }))
+            .filter(({ result }) => (result.status === "fulfilled" && result.value != null) ||
+            result.status === "rejected");
+        // Handle results and call run managers
+        const generations = [];
+        await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
+            if (promiseResult.status === "fulfilled") {
+                const result = promiseResult.value;
+                generations[i] = result.map((result) => {
+                    // eslint-disable-next-line no-param-reassign
+                    result.generationInfo = {
+                        ...result.generationInfo,
+                        tokenUsage: {},
+                    };
+                    return result;
+                });
+                if (result.length) {
+                    await runManager?.handleLLMNewToken(result[0].text);
+                }
+                return runManager?.handleLLMEnd({
+                    generations: [result],
+                }, undefined, undefined, undefined, {
+                    cached: true,
+                });
+            }
+            else {
+                // status === "rejected"
+                await runManager?.handleLLMError(promiseResult.reason, undefined, undefined, undefined, {
+                    cached: true,
+                });
+                return Promise.reject(promiseResult.reason);
+            }
+        }));
+        const output = {
+            generations,
+            missingPromptIndices,
+            startedRunManagers: runManagers,
+        };
+        // This defines RUN_KEY as a non-enumerable property on the output object
+        // so that it is not serialized when the output is stringified, and so that
+        // it isnt included when listing the keys of the output object.
+        Object.defineProperty(output, RUN_KEY, {
+            value: runManagers
+                ? { runIds: runManagers?.map((manager) => manager.runId) }
+                : undefined,
+            configurable: true,
+        });
+        return output;
+    }
+    /**
+     * Run the LLM on the given prompts and input, handling caching.
+     */
+    async generate(prompts, options, callbacks) {
+        if (!Array.isArray(prompts)) {
+            throw new Error("Argument 'prompts' is expected to be a string[]");
+        }
+        let parsedOptions;
+        if (Array.isArray(options)) {
+            parsedOptions = { stop: options };
+        }
+        else {
+            parsedOptions = options;
+        }
+        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(parsedOptions);
+        runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
+        if (!this.cache) {
+            return this._generateUncached(prompts, callOptions, runnableConfig);
+        }
+        const { cache } = this;
+        const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
+        const { generations, missingPromptIndices, startedRunManagers } = await this._generateCached({
+            prompts,
+            cache,
+            llmStringKey,
+            parsedOptions: callOptions,
+            handledOptions: runnableConfig,
+            runId: runnableConfig.runId,
+        });
+        let llmOutput = {};
+        if (missingPromptIndices.length > 0) {
+            const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig, startedRunManagers !== undefined
+                ? missingPromptIndices.map((i) => startedRunManagers?.[i])
+                : undefined);
+            await Promise.all(results.generations.map(async (generation, index) => {
+                const promptIndex = missingPromptIndices[index];
+                generations[promptIndex] = generation;
+                return cache.update(prompts[promptIndex], llmStringKey, generation);
+            }));
+            llmOutput = results.llmOutput ?? {};
+        }
+        return { generations, llmOutput };
+    }
+    /**
+     * @deprecated Use .invoke() instead. Will be removed in 0.2.0.
+     * Convenience wrapper for {@link generate} that takes in a single string prompt and returns a single string output.
+     */
+    async call(prompt, options, callbacks) {
+        const { generations } = await this.generate([prompt], options, callbacks);
+        return generations[0][0].text;
+    }
+    /**
+     * @deprecated Use .invoke() instead. Will be removed in 0.2.0.
+     *
+     * This method is similar to `call`, but it's used for making predictions
+     * based on the input text.
+     * @param text Input text for the prediction.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns A prediction based on the input text.
+     */
+    async predict(text, options, callbacks) {
+        return this.call(text, options, callbacks);
+    }
+    /**
+     * @deprecated Use .invoke() instead. Will be removed in 0.2.0.
+     *
+     * This method takes a list of messages, options, and callbacks, and
+     * returns a predicted message.
+     * @param messages A list of messages for the prediction.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns A predicted message based on the list of messages.
+     */
+    async predictMessages(messages, options, callbacks) {
+        const text = getBufferString(messages);
+        const prediction = await this.call(text, options, callbacks);
+        return new AIMessage(prediction);
+    }
+    /**
+     * Get the identifying parameters of the LLM.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _identifyingParams() {
+        return {};
+    }
+    /**
+     * @deprecated
+     * Return a json-like object representing this LLM.
+     */
+    serialize() {
+        return {
+            ...this._identifyingParams(),
+            _type: this._llmType(),
+            _model: this._modelType(),
+        };
+    }
+    _modelType() {
+        return "base_llm";
+    }
+}
+/**
+ * LLM class that provides a simpler interface to subclass than {@link BaseLLM}.
+ *
+ * Requires only implementing a simpler {@link _call} method instead of {@link _generate}.
+ *
+ * @augments BaseLLM
+ */
+export class LLM extends BaseLLM {
+    async _generate(prompts, options, runManager) {
+        const generations = await Promise.all(prompts.map((prompt, promptIndex) => this._call(prompt, { ...options, promptIndex }, runManager).then((text) => [{ text }])));
+        return { generations };
+    }
+}

package/dist/node_modules/@langchain/core/dist/load/import_constants.cjs

@@ -0,0 +1,5 @@
+"use strict";
+// Auto-generated by `scripts/create-entrypoints.js`. Do not edit manually.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalImportEntrypoints = void 0;
+exports.optionalImportEntrypoints = [];

package/dist/node_modules/@langchain/core/dist/load/import_constants.d.ts

@@ -0,0 +1 @@
+export declare const optionalImportEntrypoints: string[];

package/dist/node_modules/@langchain/core/dist/load/import_constants.js

@@ -0,0 +1,2 @@
+// Auto-generated by `scripts/create-entrypoints.js`. Do not edit manually.
+export const optionalImportEntrypoints = [];

package/dist/node_modules/@langchain/core/dist/load/import_map.cjs

@@ -0,0 +1,70 @@
+"use strict";
+// Auto-generated by `scripts/create-entrypoints.js`. Do not edit manually.
+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.vectorstores = exports.utils__types = exports.utils__tiktoken = exports.utils__testing = exports.utils__stream = exports.utils__math = exports.utils__json_schema = exports.utils__json_patch = exports.utils__hash = exports.utils__function_calling = exports.utils__env = exports.utils__chunk_array = exports.utils__async_caller = exports.tracers__tracer_langchain_v1 = exports.tracers__tracer_langchain = exports.tracers__run_collector = exports.tracers__log_stream = exports.tracers__initialize = exports.tracers__console = exports.tracers__base = exports.tools = exports.stores = exports.retrievers = exports.runnables = exports.prompt_values = exports.prompts = exports.outputs = exports.output_parsers = exports.messages = exports.memory = exports.load__serializable = exports.language_models__llms = exports.language_models__chat_models = exports.language_models__base = exports.example_selectors = exports.embeddings = exports.documents = exports.chat_history = exports.callbacks__promises = exports.callbacks__manager = exports.callbacks__base = exports.caches = exports.agents = void 0;
+exports.agents = __importStar(require("../agents.cjs"));
+exports.caches = __importStar(require("../caches/base.cjs"));
+exports.callbacks__base = __importStar(require("../callbacks/base.cjs"));
+exports.callbacks__manager = __importStar(require("../callbacks/manager.cjs"));
+exports.callbacks__promises = __importStar(require("../callbacks/promises.cjs"));
+exports.chat_history = __importStar(require("../chat_history.cjs"));
+exports.documents = __importStar(require("../documents/index.cjs"));
+exports.embeddings = __importStar(require("../embeddings.cjs"));
+exports.example_selectors = __importStar(require("../example_selectors/index.cjs"));
+exports.language_models__base = __importStar(require("../language_models/base.cjs"));
+exports.language_models__chat_models = __importStar(require("../language_models/chat_models.cjs"));
+exports.language_models__llms = __importStar(require("../language_models/llms.cjs"));
+exports.load__serializable = __importStar(require("../load/serializable.cjs"));
+exports.memory = __importStar(require("../memory.cjs"));
+exports.messages = __importStar(require("../messages/index.cjs"));
+exports.output_parsers = __importStar(require("../output_parsers/index.cjs"));
+exports.outputs = __importStar(require("../outputs.cjs"));
+exports.prompts = __importStar(require("../prompts/index.cjs"));
+exports.prompt_values = __importStar(require("../prompt_values.cjs"));
+exports.runnables = __importStar(require("../runnables/index.cjs"));
+exports.retrievers = __importStar(require("../retrievers/index.cjs"));
+exports.stores = __importStar(require("../stores.cjs"));
+exports.tools = __importStar(require("../tools/index.cjs"));
+exports.tracers__base = __importStar(require("../tracers/base.cjs"));
+exports.tracers__console = __importStar(require("../tracers/console.cjs"));
+exports.tracers__initialize = __importStar(require("../tracers/initialize.cjs"));
+exports.tracers__log_stream = __importStar(require("../tracers/log_stream.cjs"));
+exports.tracers__run_collector = __importStar(require("../tracers/run_collector.cjs"));
+exports.tracers__tracer_langchain = __importStar(require("../tracers/tracer_langchain.cjs"));
+exports.tracers__tracer_langchain_v1 = __importStar(require("../tracers/tracer_langchain_v1.cjs"));
+exports.utils__async_caller = __importStar(require("../utils/async_caller.cjs"));
+exports.utils__chunk_array = __importStar(require("../utils/chunk_array.cjs"));
+exports.utils__env = __importStar(require("../utils/env.cjs"));
+exports.utils__function_calling = __importStar(require("../utils/function_calling.cjs"));
+exports.utils__hash = __importStar(require("../utils/hash.cjs"));
+exports.utils__json_patch = __importStar(require("../utils/json_patch.cjs"));
+exports.utils__json_schema = __importStar(require("../utils/json_schema.cjs"));
+exports.utils__math = __importStar(require("../utils/math.cjs"));
+exports.utils__stream = __importStar(require("../utils/stream.cjs"));
+exports.utils__testing = __importStar(require("../utils/testing/index.cjs"));
+exports.utils__tiktoken = __importStar(require("../utils/tiktoken.cjs"));
+exports.utils__types = __importStar(require("../utils/types/index.cjs"));
+exports.vectorstores = __importStar(require("../vectorstores.cjs"));

package/dist/node_modules/@langchain/core/dist/load/import_map.d.ts

@@ -0,0 +1,43 @@
+export * as agents from "../agents.js";
+export * as caches from "../caches/base.js";
+export * as callbacks__base from "../callbacks/base.js";
+export * as callbacks__manager from "../callbacks/manager.js";
+export * as callbacks__promises from "../callbacks/promises.js";
+export * as chat_history from "../chat_history.js";
+export * as documents from "../documents/index.js";
+export * as embeddings from "../embeddings.js";
+export * as example_selectors from "../example_selectors/index.js";
+export * as language_models__base from "../language_models/base.js";
+export * as language_models__chat_models from "../language_models/chat_models.js";
+export * as language_models__llms from "../language_models/llms.js";
+export * as load__serializable from "../load/serializable.js";
+export * as memory from "../memory.js";
+export * as messages from "../messages/index.js";
+export * as output_parsers from "../output_parsers/index.js";
+export * as outputs from "../outputs.js";
+export * as prompts from "../prompts/index.js";
+export * as prompt_values from "../prompt_values.js";
+export * as runnables from "../runnables/index.js";
+export * as retrievers from "../retrievers/index.js";
+export * as stores from "../stores.js";
+export * as tools from "../tools/index.js";
+export * as tracers__base from "../tracers/base.js";
+export * as tracers__console from "../tracers/console.js";
+export * as tracers__initialize from "../tracers/initialize.js";
+export * as tracers__log_stream from "../tracers/log_stream.js";
+export * as tracers__run_collector from "../tracers/run_collector.js";
+export * as tracers__tracer_langchain from "../tracers/tracer_langchain.js";
+export * as tracers__tracer_langchain_v1 from "../tracers/tracer_langchain_v1.js";
+export * as utils__async_caller from "../utils/async_caller.js";
+export * as utils__chunk_array from "../utils/chunk_array.js";
+export * as utils__env from "../utils/env.js";
+export * as utils__function_calling from "../utils/function_calling.js";
+export * as utils__hash from "../utils/hash.js";
+export * as utils__json_patch from "../utils/json_patch.js";
+export * as utils__json_schema from "../utils/json_schema.js";
+export * as utils__math from "../utils/math.js";
+export * as utils__stream from "../utils/stream.js";
+export * as utils__testing from "../utils/testing/index.js";
+export * as utils__tiktoken from "../utils/tiktoken.js";
+export * as utils__types from "../utils/types/index.js";
+export * as vectorstores from "../vectorstores.js";

package/dist/node_modules/@langchain/core/dist/load/import_map.js

@@ -0,0 +1,44 @@
+// Auto-generated by `scripts/create-entrypoints.js`. Do not edit manually.
+export * as agents from "../agents.js";
+export * as caches from "../caches/base.js";
+export * as callbacks__base from "../callbacks/base.js";
+export * as callbacks__manager from "../callbacks/manager.js";
+export * as callbacks__promises from "../callbacks/promises.js";
+export * as chat_history from "../chat_history.js";
+export * as documents from "../documents/index.js";
+export * as embeddings from "../embeddings.js";
+export * as example_selectors from "../example_selectors/index.js";
+export * as language_models__base from "../language_models/base.js";
+export * as language_models__chat_models from "../language_models/chat_models.js";
+export * as language_models__llms from "../language_models/llms.js";
+export * as load__serializable from "../load/serializable.js";
+export * as memory from "../memory.js";
+export * as messages from "../messages/index.js";
+export * as output_parsers from "../output_parsers/index.js";
+export * as outputs from "../outputs.js";
+export * as prompts from "../prompts/index.js";
+export * as prompt_values from "../prompt_values.js";
+export * as runnables from "../runnables/index.js";
+export * as retrievers from "../retrievers/index.js";
+export * as stores from "../stores.js";
+export * as tools from "../tools/index.js";
+export * as tracers__base from "../tracers/base.js";
+export * as tracers__console from "../tracers/console.js";
+export * as tracers__initialize from "../tracers/initialize.js";
+export * as tracers__log_stream from "../tracers/log_stream.js";
+export * as tracers__run_collector from "../tracers/run_collector.js";
+export * as tracers__tracer_langchain from "../tracers/tracer_langchain.js";
+export * as tracers__tracer_langchain_v1 from "../tracers/tracer_langchain_v1.js";
+export * as utils__async_caller from "../utils/async_caller.js";
+export * as utils__chunk_array from "../utils/chunk_array.js";
+export * as utils__env from "../utils/env.js";
+export * as utils__function_calling from "../utils/function_calling.js";
+export * as utils__hash from "../utils/hash.js";
+export * as utils__json_patch from "../utils/json_patch.js";
+export * as utils__json_schema from "../utils/json_schema.js";
+export * as utils__math from "../utils/math.js";
+export * as utils__stream from "../utils/stream.js";
+export * as utils__testing from "../utils/testing/index.js";
+export * as utils__tiktoken from "../utils/tiktoken.js";
+export * as utils__types from "../utils/types/index.js";
+export * as vectorstores from "../vectorstores.js";

package/dist/node_modules/@langchain/core/dist/load/import_type.cjs

@@ -0,0 +1,3 @@
+"use strict";
+// Auto-generated by `scripts/create-entrypoints.js`. Do not edit manually.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node_modules/@langchain/core/dist/load/import_type.d.ts

@@ -0,0 +1,4 @@
+export interface OptionalImportMap {
+}
+export interface SecretMap {
+}

package/dist/node_modules/@langchain/core/dist/load/import_type.js

@@ -0,0 +1,2 @@
+// Auto-generated by `scripts/create-entrypoints.js`. Do not edit manually.
+export {};