@langchain/core 0.2.7 → 0.2.8

package/dist/messages/transformers.js

@@ -0,0 +1,414 @@
+import { RunnableLambda } from "../runnables/base.js";
+import { AIMessage, AIMessageChunk } from "./ai.js";
+import { ChatMessage, ChatMessageChunk, } from "./chat.js";
+import { FunctionMessage, FunctionMessageChunk, } from "./function.js";
+import { HumanMessage, HumanMessageChunk } from "./human.js";
+import { SystemMessage, SystemMessageChunk } from "./system.js";
+import { ToolMessage, ToolMessageChunk, } from "./tool.js";
+import { convertToChunk } from "./utils.js";
+const _isMessageType = (msg, types) => {
+    const typesAsStrings = [
+        ...new Set(types?.map((t) => {
+            if (typeof t === "string") {
+                return t;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const instantiatedMsgClass = new t({});
+            if (!("_getType" in instantiatedMsgClass) ||
+                typeof instantiatedMsgClass._getType !== "function") {
+                throw new Error("Invalid type provided.");
+            }
+            return instantiatedMsgClass._getType();
+        })),
+    ];
+    const msgType = msg._getType();
+    return typesAsStrings.some((t) => t === msgType);
+};
+export function filterMessages(messagesOrOptions, options) {
+    if (Array.isArray(messagesOrOptions)) {
+        return _filterMessages(messagesOrOptions, options);
+    }
+    return RunnableLambda.from((input) => {
+        return _filterMessages(input, messagesOrOptions);
+    });
+}
+function _filterMessages(messages, options = {}) {
+    const { includeNames, excludeNames, includeTypes, excludeTypes, includeIds, excludeIds, } = options;
+    const filtered = [];
+    for (const msg of messages) {
+        if (excludeNames && msg.name && excludeNames.includes(msg.name)) {
+            continue;
+        }
+        else if (excludeTypes && _isMessageType(msg, excludeTypes)) {
+            continue;
+        }
+        else if (excludeIds && msg.id && excludeIds.includes(msg.id)) {
+            continue;
+        }
+        // default to inclusion when no inclusion criteria given.
+        if (!(includeTypes || includeIds || includeNames)) {
+            filtered.push(msg);
+        }
+        else if (includeNames &&
+            msg.name &&
+            includeNames.some((iName) => iName === msg.name)) {
+            filtered.push(msg);
+        }
+        else if (includeTypes && _isMessageType(msg, includeTypes)) {
+            filtered.push(msg);
+        }
+        else if (includeIds && msg.id && includeIds.some((id) => id === msg.id)) {
+            filtered.push(msg);
+        }
+    }
+    return filtered;
+}
+export function mergeMessageRuns(messages) {
+    if (Array.isArray(messages)) {
+        return _mergeMessageRuns(messages);
+    }
+    return RunnableLambda.from(_mergeMessageRuns);
+}
+function _mergeMessageRuns(messages) {
+    if (!messages.length) {
+        return [];
+    }
+    const merged = [];
+    for (const msg of messages) {
+        const curr = msg; // Create a shallow copy of the message
+        const last = merged.pop();
+        if (!last) {
+            merged.push(curr);
+        }
+        else if (curr._getType() === "tool" ||
+            !(curr._getType() === last._getType())) {
+            merged.push(last, curr);
+        }
+        else {
+            const lastChunk = convertToChunk(last);
+            const currChunk = convertToChunk(curr);
+            const mergedChunks = lastChunk.concat(currChunk);
+            if (typeof lastChunk.content === "string" &&
+                typeof currChunk.content === "string") {
+                mergedChunks.content = `${lastChunk.content}\n${currChunk.content}`;
+            }
+            merged.push(_chunkToMsg(mergedChunks));
+        }
+    }
+    return merged;
+}
+export function trimMessages(messagesOrOptions, options) {
+    if (Array.isArray(messagesOrOptions)) {
+        const messages = messagesOrOptions;
+        if (!options) {
+            throw new Error("Options parameter is required when providing messages.");
+        }
+        return _trimMessagesHelper(messages, options);
+    }
+    else {
+        const trimmerOptions = messagesOrOptions;
+        return RunnableLambda.from((input) => _trimMessagesHelper(input, trimmerOptions));
+    }
+}
+async function _trimMessagesHelper(messages, options) {
+    const { maxTokens, tokenCounter, strategy = "last", allowPartial = false, endOn, startOn, includeSystem = false, textSplitter, } = options;
+    if (startOn && strategy === "first") {
+        throw new Error("`startOn` should only be specified if `strategy` is 'last'.");
+    }
+    if (includeSystem && strategy === "first") {
+        throw new Error("`includeSystem` should only be specified if `strategy` is 'last'.");
+    }
+    let listTokenCounter;
+    if ("getNumTokens" in tokenCounter) {
+        listTokenCounter = async (msgs) => {
+            const tokenCounts = await Promise.all(msgs.map((msg) => tokenCounter.getNumTokens(msg.content)));
+            return tokenCounts.reduce((sum, count) => sum + count, 0);
+        };
+    }
+    else {
+        listTokenCounter = async (msgs) => tokenCounter(msgs);
+    }
+    let textSplitterFunc = defaultTextSplitter;
+    if (textSplitter) {
+        if ("splitText" in textSplitter) {
+            textSplitterFunc = textSplitter.splitText;
+        }
+        else {
+            textSplitterFunc = async (text) => textSplitter(text);
+        }
+    }
+    if (strategy === "first") {
+        return _firstMaxTokens(messages, {
+            maxTokens,
+            tokenCounter: listTokenCounter,
+            textSplitter: textSplitterFunc,
+            partialStrategy: allowPartial ? "first" : undefined,
+            endOn,
+        });
+    }
+    else if (strategy === "last") {
+        return _lastMaxTokens(messages, {
+            maxTokens,
+            tokenCounter: listTokenCounter,
+            textSplitter: textSplitterFunc,
+            allowPartial,
+            includeSystem,
+            startOn,
+            endOn,
+        });
+    }
+    else {
+        throw new Error(`Unrecognized strategy: '${strategy}'. Must be one of 'first' or 'last'.`);
+    }
+}
+async function _firstMaxTokens(messages, options) {
+    const { maxTokens, tokenCounter, textSplitter, partialStrategy, endOn } = options;
+    let messagesCopy = [...messages];
+    let idx = 0;
+    for (let i = 0; i < messagesCopy.length; i += 1) {
+        const remainingMessages = i > 0 ? messagesCopy.slice(0, -i) : messagesCopy;
+        if ((await tokenCounter(remainingMessages)) <= maxTokens) {
+            idx = messagesCopy.length - i;
+            break;
+        }
+    }
+    if (idx < messagesCopy.length - 1 && partialStrategy) {
+        let includedPartial = false;
+        if (Array.isArray(messagesCopy[idx].content)) {
+            const excluded = messagesCopy[idx];
+            if (typeof excluded.content === "string") {
+                throw new Error("Expected content to be an array.");
+            }
+            const numBlock = excluded.content.length;
+            const reversedContent = partialStrategy === "last"
+                ? [...excluded.content].reverse()
+                : excluded.content;
+            for (let i = 1; i <= numBlock; i += 1) {
+                const partialContent = partialStrategy === "first"
+                    ? reversedContent.slice(0, i)
+                    : reversedContent.slice(-i);
+                const fields = Object.fromEntries(Object.entries(excluded).filter(([k]) => k !== "type" && !k.startsWith("lc_")));
+                const updatedMessage = _switchTypeToMessage(excluded._getType(), {
+                    ...fields,
+                    content: partialContent,
+                });
+                const slicedMessages = [...messagesCopy.slice(0, idx), updatedMessage];
+                if ((await tokenCounter(slicedMessages)) <= maxTokens) {
+                    messagesCopy = slicedMessages;
+                    idx += 1;
+                    includedPartial = true;
+                }
+                else {
+                    break;
+                }
+            }
+            if (includedPartial && partialStrategy === "last") {
+                excluded.content = [...reversedContent].reverse();
+            }
+        }
+        if (!includedPartial) {
+            const excluded = messagesCopy[idx];
+            let text;
+            if (Array.isArray(excluded.content) &&
+                excluded.content.some((block) => typeof block === "string" || block.type === "text")) {
+                const textBlock = excluded.content.find((block) => block.type === "text" && block.text);
+                text = textBlock?.text;
+            }
+            else if (typeof excluded.content === "string") {
+                text = excluded.content;
+            }
+            if (text) {
+                const splitTexts = await textSplitter(text);
+                const numSplits = splitTexts.length;
+                if (partialStrategy === "last") {
+                    splitTexts.reverse();
+                }
+                for (let _ = 0; _ < numSplits - 1; _ += 1) {
+                    splitTexts.pop();
+                    excluded.content = splitTexts.join("");
+                    if ((await tokenCounter([...messagesCopy.slice(0, idx), excluded])) <=
+                        maxTokens) {
+                        if (partialStrategy === "last") {
+                            excluded.content = [...splitTexts].reverse().join("");
+                        }
+                        messagesCopy = [...messagesCopy.slice(0, idx), excluded];
+                        idx += 1;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (endOn) {
+        const endOnArr = Array.isArray(endOn) ? endOn : [endOn];
+        while (idx > 0 && !_isMessageType(messagesCopy[idx - 1], endOnArr)) {
+            idx -= 1;
+        }
+    }
+    return messagesCopy.slice(0, idx);
+}
+async function _lastMaxTokens(messages, options) {
+    const { allowPartial = false, includeSystem = false, endOn, startOn, ...rest } = options;
+    if (endOn) {
+        const endOnArr = Array.isArray(endOn) ? endOn : [endOn];
+        while (messages &&
+            !_isMessageType(messages[messages.length - 1], endOnArr)) {
+            messages.pop();
+        }
+    }
+    const swappedSystem = includeSystem && messages[0]._getType() === "system";
+    let reversed_ = swappedSystem
+        ? messages.slice(0, 1).concat(messages.slice(1).reverse())
+        : messages.reverse();
+    reversed_ = await _firstMaxTokens(reversed_, {
+        ...rest,
+        partialStrategy: allowPartial ? "last" : undefined,
+        endOn: startOn,
+    });
+    if (swappedSystem) {
+        return [reversed_[0], ...reversed_.slice(1).reverse()];
+    }
+    else {
+        return reversed_.reverse();
+    }
+}
+const _MSG_CHUNK_MAP = {
+    human: {
+        message: HumanMessage,
+        messageChunk: HumanMessageChunk,
+    },
+    ai: {
+        message: AIMessage,
+        messageChunk: AIMessageChunk,
+    },
+    system: {
+        message: SystemMessage,
+        messageChunk: SystemMessageChunk,
+    },
+    tool: {
+        message: ToolMessage,
+        messageChunk: ToolMessageChunk,
+    },
+    function: {
+        message: FunctionMessage,
+        messageChunk: FunctionMessageChunk,
+    },
+    generic: {
+        message: ChatMessage,
+        messageChunk: ChatMessageChunk,
+    },
+};
+function _switchTypeToMessage(messageType, fields, returnChunk) {
+    let chunk;
+    let msg;
+    switch (messageType) {
+        case "human":
+            if (returnChunk) {
+                chunk = new HumanMessageChunk(fields);
+            }
+            else {
+                msg = new HumanMessage(fields);
+            }
+            break;
+        case "ai":
+            if (returnChunk) {
+                let aiChunkFields = {
+                    ...fields,
+                };
+                if ("tool_calls" in aiChunkFields) {
+                    aiChunkFields = {
+                        ...aiChunkFields,
+                        tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
+                            ...tc,
+                            index: undefined,
+                            args: JSON.stringify(tc.args),
+                        })),
+                    };
+                }
+                chunk = new AIMessageChunk(aiChunkFields);
+            }
+            else {
+                msg = new AIMessage(fields);
+            }
+            break;
+        case "system":
+            if (returnChunk) {
+                chunk = new SystemMessageChunk(fields);
+            }
+            else {
+                msg = new SystemMessage(fields);
+            }
+            break;
+        case "tool":
+            if ("tool_call_id" in fields) {
+                if (returnChunk) {
+                    chunk = new ToolMessageChunk(fields);
+                }
+                else {
+                    msg = new ToolMessage(fields);
+                }
+            }
+            else {
+                throw new Error("Can not convert ToolMessage to ToolMessageChunk if 'tool_call_id' field is not defined.");
+            }
+            break;
+        case "function":
+            if (returnChunk) {
+                chunk = new FunctionMessageChunk(fields);
+            }
+            else {
+                if (!fields.name) {
+                    throw new Error("FunctionMessage must have a 'name' field");
+                }
+                msg = new FunctionMessage(fields);
+            }
+            break;
+        case "generic":
+            if ("role" in fields) {
+                if (returnChunk) {
+                    chunk = new ChatMessageChunk(fields);
+                }
+                else {
+                    msg = new ChatMessage(fields);
+                }
+            }
+            else {
+                throw new Error("Can not convert ChatMessage to ChatMessageChunk if 'role' field is not defined.");
+            }
+            break;
+        default:
+            throw new Error(`Unrecognized message type ${messageType}`);
+    }
+    if (returnChunk && chunk) {
+        return chunk;
+    }
+    if (msg) {
+        return msg;
+    }
+    throw new Error(`Unrecognized message type ${messageType}`);
+}
+function _chunkToMsg(chunk) {
+    const chunkType = chunk._getType();
+    let msg;
+    const fields = Object.fromEntries(Object.entries(chunk).filter(([k]) => !["type", "tool_call_chunks"].includes(k) && !k.startsWith("lc_")));
+    if (chunkType in _MSG_CHUNK_MAP) {
+        msg = _switchTypeToMessage(chunkType, fields);
+    }
+    if (!msg) {
+        throw new Error(`Unrecognized message chunk class ${chunkType}. Supported classes are ${Object.keys(_MSG_CHUNK_MAP)}`);
+    }
+    return msg;
+}
+/**
+ * The default text splitter function that splits text by newlines.
+ *
+ * @param {string} text
+ * @returns A promise that resolves to an array of strings split by newlines.
+ */
+export function defaultTextSplitter(text) {
+    const splits = text.split("\n");
+    return Promise.resolve([
+        ...splits.slice(0, -1).map((s) => `${s}\n`),
+        splits[splits.length - 1],
+    ]);
+}

package/dist/messages/utils.cjs

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToChunk = exports.mapChatMessagesToStoredMessages = exports.mapStoredMessagesToChatMessages = exports.mapStoredMessageToChatMessage = exports.getBufferString = exports.coerceMessageLikeToMessage = void 0;
-const base_js_1 = require("./base.cjs");
-const human_js_1 = require("./human.cjs");
 const ai_js_1 = require("./ai.cjs");
-const system_js_1 = require("./system.cjs");
+const base_js_1 = require("./base.cjs");
 const chat_js_1 = require("./chat.cjs");
 const function_js_1 = require("./function.cjs");
+const human_js_1 = require("./human.cjs");
+const system_js_1 = require("./system.cjs");
 const tool_js_1 = require("./tool.cjs");
 function coerceMessageLikeToMessage(messageLike) {
     if (typeof messageLike === "string") {
@@ -149,8 +149,21 @@ function convertToChunk(message) {
         return new human_js_1.HumanMessageChunk({ ...message });
     }
     else if (type === "ai") {
+        let aiChunkFields = {
+            ...message,
+        };
+        if ("tool_calls" in aiChunkFields) {
+            aiChunkFields = {
+                ...aiChunkFields,
+                tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
+                    ...tc,
+                    index: undefined,
+                    args: JSON.stringify(tc.args),
+                })),
+            };
+        }
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new ai_js_1.AIMessageChunk({ ...message });
+        return new ai_js_1.AIMessageChunk({ ...aiChunkFields });
     }
     else if (type === "system") {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define

package/dist/messages/utils.d.ts

@@ -1,9 +1,9 @@
-import { BaseMessageLike, BaseMessage, StoredMessage } from "./base.js";
-import { HumanMessage, HumanMessageChunk } from "./human.js";
 import { AIMessage, AIMessageChunk } from "./ai.js";
-import { SystemMessage, SystemMessageChunk } from "./system.js";
+import { BaseMessageLike, BaseMessage, StoredMessage } from "./base.js";
 import { ChatMessage, ChatMessageChunk } from "./chat.js";
 import { FunctionMessage, FunctionMessageChunk } from "./function.js";
+import { HumanMessage, HumanMessageChunk } from "./human.js";
+import { SystemMessage, SystemMessageChunk } from "./system.js";
 import { ToolMessage } from "./tool.js";
 export declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;
 /**

package/dist/messages/utils.js

@@ -1,9 +1,9 @@
-import { isBaseMessage, } from "./base.js";
-import { HumanMessage, HumanMessageChunk } from "./human.js";
 import { AIMessage, AIMessageChunk } from "./ai.js";
-import { SystemMessage, SystemMessageChunk } from "./system.js";
+import { isBaseMessage, } from "./base.js";
 import { ChatMessage, ChatMessageChunk, } from "./chat.js";
 import { FunctionMessage, FunctionMessageChunk, } from "./function.js";
+import { HumanMessage, HumanMessageChunk } from "./human.js";
+import { SystemMessage, SystemMessageChunk } from "./system.js";
 import { ToolMessage } from "./tool.js";
 export function coerceMessageLikeToMessage(messageLike) {
     if (typeof messageLike === "string") {
@@ -141,8 +141,21 @@ export function convertToChunk(message) {
         return new HumanMessageChunk({ ...message });
     }
     else if (type === "ai") {
+        let aiChunkFields = {
+            ...message,
+        };
+        if ("tool_calls" in aiChunkFields) {
+            aiChunkFields = {
+                ...aiChunkFields,
+                tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
+                    ...tc,
+                    index: undefined,
+                    args: JSON.stringify(tc.args),
+                })),
+            };
+        }
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new AIMessageChunk({ ...message });
+        return new AIMessageChunk({ ...aiChunkFields });
     }
     else if (type === "system") {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define

package/dist/outputs.d.ts

@@ -1,4 +1,4 @@
-import { type BaseMessage, type BaseMessageChunk } from "./messages/index.js";
+import { type BaseMessage, type BaseMessageChunk } from "./messages/base.js";
 export declare const RUN_KEY = "__run";
 /**
  * Output of a single generation.

package/dist/prompt_values.cjs

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImagePromptValue = exports.ChatPromptValue = exports.StringPromptValue = exports.BasePromptValue = void 0;
 const serializable_js_1 = require("./load/serializable.cjs");
-const index_js_1 = require("./messages/index.cjs");
+const human_js_1 = require("./messages/human.cjs");
+const utils_js_1 = require("./messages/utils.cjs");
 /**
  * Base PromptValue class. All prompt values should extend this class.
  */
@@ -43,7 +44,7 @@ class StringPromptValue extends BasePromptValue {
         return this.value;
     }
     toChatMessages() {
-        return [new index_js_1.HumanMessage(this.value)];
+        return [new human_js_1.HumanMessage(this.value)];
     }
 }
 exports.StringPromptValue = StringPromptValue;
@@ -82,7 +83,7 @@ class ChatPromptValue extends BasePromptValue {
         this.messages = fields.messages;
     }
     toString() {
-        return (0, index_js_1.getBufferString)(this.messages);
+        return (0, utils_js_1.getBufferString)(this.messages);
     }
     toChatMessages() {
         return this.messages;
@@ -135,7 +136,7 @@ class ImagePromptValue extends BasePromptValue {
     }
     toChatMessages() {
         return [
-            new index_js_1.HumanMessage({
+            new human_js_1.HumanMessage({
                 content: [
                     {
                         type: "image_url",

package/dist/prompt_values.d.ts

@@ -1,5 +1,6 @@
 import { Serializable } from "./load/serializable.js";
-import { type BaseMessage, HumanMessage } from "./messages/index.js";
+import { type BaseMessage } from "./messages/base.js";
+import { HumanMessage } from "./messages/human.js";
 export interface BasePromptValueInterface extends Serializable {
     toString(): string;
     toChatMessages(): BaseMessage[];

package/dist/prompt_values.js

@@ -1,5 +1,6 @@
 import { Serializable } from "./load/serializable.js";
-import { HumanMessage, getBufferString, } from "./messages/index.js";
+import { HumanMessage } from "./messages/human.js";
+import { getBufferString } from "./messages/utils.js";
 /**
  * Base PromptValue class. All prompt values should extend this class.
  */

package/dist/tracers/base.d.ts

@@ -2,7 +2,7 @@ import { KVMap, BaseRun } from "langsmith/schemas";
 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";
+import type { BaseMessage } from "../messages/base.js";
 import { Serialized } from "../load/serializable.js";
 import { BaseCallbackHandler, BaseCallbackHandlerInput, HandleLLMNewTokenCallbackFields, NewTokenIndices } from "../callbacks/base.js";
 import type { Document } from "../documents/document.js";

package/dist/tracers/log_stream.cjs

@@ -4,7 +4,7 @@ exports.LogStreamCallbackHandler = exports.isLogStreamHandler = exports.RunLog =
 const index_js_1 = require("../utils/fast-json-patch/index.cjs");
 const base_js_1 = require("./base.cjs");
 const stream_js_1 = require("../utils/stream.cjs");
-const index_js_2 = require("../messages/index.cjs");
+const ai_js_1 = require("../messages/ai.cjs");
 /**
  * List of jsonpatch JSONPatchOperations, which describe how to create the run state
  * from an empty dict. This is the minimal representation of the log, designed to
@@ -401,7 +401,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
                 streamedOutputValue = kwargs?.chunk;
             }
             else {
-                streamedOutputValue = new index_js_2.AIMessageChunk(token);
+                streamedOutputValue = new ai_js_1.AIMessageChunk(token);
             }
         }
         else {

package/dist/tracers/log_stream.js

@@ -1,7 +1,7 @@
 import { applyPatch, } from "../utils/fast-json-patch/index.js";
 import { BaseTracer } from "./base.js";
 import { IterableReadableStream } from "../utils/stream.js";
-import { AIMessageChunk } from "../messages/index.js";
+import { AIMessageChunk } from "../messages/ai.js";
 /**
  * List of jsonpatch JSONPatchOperations, which describe how to create the run state
  * from an empty dict. This is the minimal representation of the log, designed to

package/dist/tracers/tracer_langchain_v1.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LangChainTracerV1 = void 0;
-const index_js_1 = require("../messages/index.cjs");
+const utils_js_1 = require("../messages/utils.cjs");
 const env_js_1 = require("../utils/env.cjs");
 const base_js_1 = require("./base.cjs");
 /** @deprecated Use LangChainTracer instead. */
@@ -63,7 +63,7 @@ class LangChainTracerV1 extends base_js_1.BaseTracer {
         if (run.run_type === "llm") {
             const prompts = run.inputs.prompts
                 ? run.inputs.prompts
-                : run.inputs.messages.map((x) => (0, index_js_1.getBufferString)(x));
+                : run.inputs.messages.map((x) => (0, utils_js_1.getBufferString)(x));
             const llmRun = {
                 uuid: run.id,
                 start_time: run.start_time,

package/dist/tracers/tracer_langchain_v1.js

@@ -1,4 +1,4 @@
-import { getBufferString } from "../messages/index.js";
+import { getBufferString } from "../messages/utils.js";
 import { getEnvironmentVariable } from "../utils/env.js";
 import { BaseTracer } from "./base.js";
 /** @deprecated Use LangChainTracer instead. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {