@langchain/core 0.1.55 → 0.1.57

package/dist/messages/tool.cjs

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultToolCallParser = exports.ToolMessageChunk = exports.ToolMessage = void 0;
+const base_js_1 = require("./base.cjs");
+/**
+ * Represents a tool message in a conversation.
+ */
+class ToolMessage extends base_js_1.BaseMessage {
+    static lc_name() {
+        return "ToolMessage";
+    }
+    get lc_aliases() {
+        // exclude snake case conversion to pascal case
+        return { tool_call_id: "tool_call_id" };
+    }
+    constructor(fields, tool_call_id, name) {
+        if (typeof fields === "string") {
+            // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion
+            fields = { content: fields, name, tool_call_id: tool_call_id };
+        }
+        super(fields);
+        Object.defineProperty(this, "tool_call_id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tool_call_id = fields.tool_call_id;
+    }
+    _getType() {
+        return "tool";
+    }
+    static isInstance(message) {
+        return message._getType() === "tool";
+    }
+}
+exports.ToolMessage = ToolMessage;
+/**
+ * Represents a chunk of a tool message, which can be concatenated
+ * with other tool message chunks.
+ */
+class ToolMessageChunk extends base_js_1.BaseMessageChunk {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "tool_call_id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tool_call_id = fields.tool_call_id;
+    }
+    static lc_name() {
+        return "ToolMessageChunk";
+    }
+    _getType() {
+        return "tool";
+    }
+    concat(chunk) {
+        return new ToolMessageChunk({
+            content: (0, base_js_1.mergeContent)(this.content, chunk.content),
+            additional_kwargs: (0, base_js_1._mergeDicts)(this.additional_kwargs, chunk.additional_kwargs),
+            response_metadata: (0, base_js_1._mergeDicts)(this.response_metadata, chunk.response_metadata),
+            tool_call_id: this.tool_call_id,
+        });
+    }
+}
+exports.ToolMessageChunk = ToolMessageChunk;
+function defaultToolCallParser(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+rawToolCalls) {
+    const toolCalls = [];
+    const invalidToolCalls = [];
+    for (const toolCall of rawToolCalls) {
+        if (!toolCall.function) {
+            continue;
+        }
+        else {
+            const functionName = toolCall.function.name;
+            try {
+                const functionArgs = JSON.parse(toolCall.function.arguments);
+                const parsed = {
+                    name: functionName || "",
+                    args: functionArgs || {},
+                    id: toolCall.id,
+                };
+                toolCalls.push(parsed);
+            }
+            catch (error) {
+                invalidToolCalls.push({
+                    name: functionName,
+                    args: toolCall.function.arguments,
+                    id: toolCall.id,
+                    error: "Malformed args.",
+                });
+            }
+        }
+    }
+    return [toolCalls, invalidToolCalls];
+}
+exports.defaultToolCallParser = defaultToolCallParser;

package/dist/messages/tool.d.ts

@@ -0,0 +1,101 @@
+import { BaseMessage, BaseMessageChunk, type BaseMessageFields, type MessageType } from "./base.js";
+export interface ToolMessageFieldsWithToolCallId extends BaseMessageFields {
+    tool_call_id: string;
+}
+/**
+ * Represents a tool message in a conversation.
+ */
+export declare class ToolMessage extends BaseMessage {
+    static lc_name(): string;
+    get lc_aliases(): Record<string, string>;
+    tool_call_id: string;
+    constructor(fields: ToolMessageFieldsWithToolCallId);
+    constructor(fields: string | BaseMessageFields, tool_call_id: string, name?: string);
+    _getType(): MessageType;
+    static isInstance(message: BaseMessage): message is ToolMessage;
+}
+/**
+ * Represents a chunk of a tool message, which can be concatenated
+ * with other tool message chunks.
+ */
+export declare class ToolMessageChunk extends BaseMessageChunk {
+    tool_call_id: string;
+    constructor(fields: ToolMessageFieldsWithToolCallId);
+    static lc_name(): string;
+    _getType(): MessageType;
+    concat(chunk: ToolMessageChunk): ToolMessageChunk;
+}
+/**
+ * A call to a tool.
+ * @property {string} name - The name of the tool to be called
+ * @property {Record<string, any>} args - The arguments to the tool call
+ * @property {string} [id] - If provided, an identifier associated with the tool call
+ */
+export type ToolCall = {
+    name: string;
+    args: Record<string, any>;
+    id?: string;
+};
+/**
+ * A chunk of a tool call (e.g., as part of a stream).
+ * When merging ToolCallChunks (e.g., via AIMessageChunk.__add__),
+ * all string attributes are concatenated. Chunks are only merged if their
+ * values of `index` are equal and not None.
+ *
+ * @example
+ * ```ts
+ * const leftChunks = [
+ *   {
+ *     name: "foo",
+ *     args: '{"a":',
+ *     index: 0
+ *   }
+ * ];
+ *
+ * const leftAIMessageChunk = new AIMessageChunk({
+ *   content: "",
+ *   tool_call_chunks: leftChunks
+ * });
+ *
+ * const rightChunks = [
+ *   {
+ *     name: undefined,
+ *     args: '1}',
+ *     index: 0
+ *   }
+ * ];
+ *
+ * const rightAIMessageChunk = new AIMessageChunk({
+ *   content: "",
+ *   tool_call_chunks: rightChunks
+ * });
+ *
+ * const result = leftAIMessageChunk.concat(rightAIMessageChunk);
+ * // result.tool_call_chunks is equal to:
+ * // [
+ * //   {
+ * //     name: "foo",
+ * //     args: '{"a":1}'
+ * //     index: 0
+ * //   }
+ * // ]
+ * ```
+ *
+ * @property {string} [name] - If provided, a substring of the name of the tool to be called
+ * @property {string} [args] - If provided, a JSON substring of the arguments to the tool call
+ * @property {string} [id] - If provided, a substring of an identifier for the tool call
+ * @property {number} [index] - If provided, the index of the tool call in a sequence
+ */
+export type ToolCallChunk = {
+    name?: string;
+    args?: string;
+    id?: string;
+    index?: number;
+};
+export type InvalidToolCall = {
+    name?: string;
+    args?: string;
+    id?: string;
+    error?: string;
+};
+export declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];

package/dist/messages/tool.js

@@ -0,0 +1,95 @@
+import { BaseMessage, BaseMessageChunk, mergeContent, _mergeDicts, } from "./base.js";
+/**
+ * Represents a tool message in a conversation.
+ */
+export class ToolMessage extends BaseMessage {
+    static lc_name() {
+        return "ToolMessage";
+    }
+    get lc_aliases() {
+        // exclude snake case conversion to pascal case
+        return { tool_call_id: "tool_call_id" };
+    }
+    constructor(fields, tool_call_id, name) {
+        if (typeof fields === "string") {
+            // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion
+            fields = { content: fields, name, tool_call_id: tool_call_id };
+        }
+        super(fields);
+        Object.defineProperty(this, "tool_call_id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tool_call_id = fields.tool_call_id;
+    }
+    _getType() {
+        return "tool";
+    }
+    static isInstance(message) {
+        return message._getType() === "tool";
+    }
+}
+/**
+ * Represents a chunk of a tool message, which can be concatenated
+ * with other tool message chunks.
+ */
+export class ToolMessageChunk extends BaseMessageChunk {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "tool_call_id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tool_call_id = fields.tool_call_id;
+    }
+    static lc_name() {
+        return "ToolMessageChunk";
+    }
+    _getType() {
+        return "tool";
+    }
+    concat(chunk) {
+        return new ToolMessageChunk({
+            content: mergeContent(this.content, chunk.content),
+            additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
+            response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
+            tool_call_id: this.tool_call_id,
+        });
+    }
+}
+export function defaultToolCallParser(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+rawToolCalls) {
+    const toolCalls = [];
+    const invalidToolCalls = [];
+    for (const toolCall of rawToolCalls) {
+        if (!toolCall.function) {
+            continue;
+        }
+        else {
+            const functionName = toolCall.function.name;
+            try {
+                const functionArgs = JSON.parse(toolCall.function.arguments);
+                const parsed = {
+                    name: functionName || "",
+                    args: functionArgs || {},
+                    id: toolCall.id,
+                };
+                toolCalls.push(parsed);
+            }
+            catch (error) {
+                invalidToolCalls.push({
+                    name: functionName,
+                    args: toolCall.function.arguments,
+                    id: toolCall.id,
+                    error: "Malformed args.",
+                });
+            }
+        }
+    }
+    return [toolCalls, invalidToolCalls];
+}

package/dist/messages/utils.cjs

@@ -0,0 +1,172 @@
+"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 chat_js_1 = require("./chat.cjs");
+const function_js_1 = require("./function.cjs");
+const tool_js_1 = require("./tool.cjs");
+function coerceMessageLikeToMessage(messageLike) {
+    if (typeof messageLike === "string") {
+        return new human_js_1.HumanMessage(messageLike);
+    }
+    else if ((0, base_js_1.isBaseMessage)(messageLike)) {
+        return messageLike;
+    }
+    const [type, content] = messageLike;
+    if (type === "human" || type === "user") {
+        return new human_js_1.HumanMessage({ content });
+    }
+    else if (type === "ai" || type === "assistant") {
+        return new ai_js_1.AIMessage({ content });
+    }
+    else if (type === "system") {
+        return new system_js_1.SystemMessage({ content });
+    }
+    else {
+        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.`);
+    }
+}
+exports.coerceMessageLikeToMessage = coerceMessageLikeToMessage;
+/**
+ * This function is used by memory classes to get a string representation
+ * of the chat message history, based on the message content and role.
+ */
+function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
+    const string_messages = [];
+    for (const m of messages) {
+        let role;
+        if (m._getType() === "human") {
+            role = humanPrefix;
+        }
+        else if (m._getType() === "ai") {
+            role = aiPrefix;
+        }
+        else if (m._getType() === "system") {
+            role = "System";
+        }
+        else if (m._getType() === "function") {
+            role = "Function";
+        }
+        else if (m._getType() === "tool") {
+            role = "Tool";
+        }
+        else if (m._getType() === "generic") {
+            role = m.role;
+        }
+        else {
+            throw new Error(`Got unsupported message type: ${m._getType()}`);
+        }
+        const nameStr = m.name ? `${m.name}, ` : "";
+        string_messages.push(`${role}: ${nameStr}${m.content}`);
+    }
+    return string_messages.join("\n");
+}
+exports.getBufferString = getBufferString;
+/**
+ * Maps messages from an older format (V1) to the current `StoredMessage`
+ * format. If the message is already in the `StoredMessage` format, it is
+ * returned as is. Otherwise, it transforms the V1 message into a
+ * `StoredMessage`. This function is important for maintaining
+ * compatibility with older message formats.
+ */
+function mapV1MessageToStoredMessage(message) {
+    // TODO: Remove this mapper when we deprecate the old message format.
+    if (message.data !== undefined) {
+        return message;
+    }
+    else {
+        const v1Message = message;
+        return {
+            type: v1Message.type,
+            data: {
+                content: v1Message.text,
+                role: v1Message.role,
+                name: undefined,
+                tool_call_id: undefined,
+            },
+        };
+    }
+}
+function mapStoredMessageToChatMessage(message) {
+    const storedMessage = mapV1MessageToStoredMessage(message);
+    switch (storedMessage.type) {
+        case "human":
+            return new human_js_1.HumanMessage(storedMessage.data);
+        case "ai":
+            return new ai_js_1.AIMessage(storedMessage.data);
+        case "system":
+            return new system_js_1.SystemMessage(storedMessage.data);
+        case "function":
+            if (storedMessage.data.name === undefined) {
+                throw new Error("Name must be defined for function messages");
+            }
+            return new function_js_1.FunctionMessage(storedMessage.data);
+        case "tool":
+            if (storedMessage.data.tool_call_id === undefined) {
+                throw new Error("Tool call ID must be defined for tool messages");
+            }
+            return new tool_js_1.ToolMessage(storedMessage.data);
+        case "chat": {
+            if (storedMessage.data.role === undefined) {
+                throw new Error("Role must be defined for chat messages");
+            }
+            return new chat_js_1.ChatMessage(storedMessage.data);
+        }
+        default:
+            throw new Error(`Got unexpected type: ${storedMessage.type}`);
+    }
+}
+exports.mapStoredMessageToChatMessage = mapStoredMessageToChatMessage;
+/**
+ * Transforms an array of `StoredMessage` instances into an array of
+ * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`
+ * function to ensure all messages are in the `StoredMessage` format, then
+ * creates new instances of the appropriate `BaseMessage` subclass based
+ * on the type of each message. This function is used to prepare stored
+ * messages for use in a chat context.
+ */
+function mapStoredMessagesToChatMessages(messages) {
+    return messages.map(mapStoredMessageToChatMessage);
+}
+exports.mapStoredMessagesToChatMessages = mapStoredMessagesToChatMessages;
+/**
+ * Transforms an array of `BaseMessage` instances into an array of
+ * `StoredMessage` instances. It does this by calling the `toDict` method
+ * on each `BaseMessage`, which returns a `StoredMessage`. This function
+ * is used to prepare chat messages for storage.
+ */
+function mapChatMessagesToStoredMessages(messages) {
+    return messages.map((message) => message.toDict());
+}
+exports.mapChatMessagesToStoredMessages = mapChatMessagesToStoredMessages;
+function convertToChunk(message) {
+    const type = message._getType();
+    if (type === "human") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new human_js_1.HumanMessageChunk({ ...message });
+    }
+    else if (type === "ai") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new ai_js_1.AIMessageChunk({ ...message });
+    }
+    else if (type === "system") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new system_js_1.SystemMessageChunk({ ...message });
+    }
+    else if (type === "function") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new function_js_1.FunctionMessageChunk({ ...message });
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    }
+    else if (chat_js_1.ChatMessage.isInstance(message)) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new chat_js_1.ChatMessageChunk({ ...message });
+    }
+    else {
+        throw new Error("Unknown message type.");
+    }
+}
+exports.convertToChunk = convertToChunk;

package/dist/messages/utils.d.ts

@@ -0,0 +1,31 @@
+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 { ChatMessage, ChatMessageChunk } from "./chat.js";
+import { FunctionMessage, FunctionMessageChunk } from "./function.js";
+import { ToolMessage } from "./tool.js";
+export declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;
+/**
+ * This function is used by memory classes to get a string representation
+ * of the chat message history, based on the message content and role.
+ */
+export declare function getBufferString(messages: BaseMessage[], humanPrefix?: string, aiPrefix?: string): string;
+export declare function mapStoredMessageToChatMessage(message: StoredMessage): ToolMessage | AIMessage | ChatMessage | FunctionMessage | HumanMessage | SystemMessage;
+/**
+ * Transforms an array of `StoredMessage` instances into an array of
+ * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`
+ * function to ensure all messages are in the `StoredMessage` format, then
+ * creates new instances of the appropriate `BaseMessage` subclass based
+ * on the type of each message. This function is used to prepare stored
+ * messages for use in a chat context.
+ */
+export declare function mapStoredMessagesToChatMessages(messages: StoredMessage[]): BaseMessage[];
+/**
+ * Transforms an array of `BaseMessage` instances into an array of
+ * `StoredMessage` instances. It does this by calling the `toDict` method
+ * on each `BaseMessage`, which returns a `StoredMessage`. This function
+ * is used to prepare chat messages for storage.
+ */
+export declare function mapChatMessagesToStoredMessages(messages: BaseMessage[]): StoredMessage[];
+export declare function convertToChunk(message: BaseMessage): AIMessageChunk | ChatMessageChunk | FunctionMessageChunk | HumanMessageChunk | SystemMessageChunk;

package/dist/messages/utils.js

@@ -0,0 +1,163 @@
+import { isBaseMessage, } from "./base.js";
+import { HumanMessage, HumanMessageChunk } from "./human.js";
+import { AIMessage, AIMessageChunk } from "./ai.js";
+import { SystemMessage, SystemMessageChunk } from "./system.js";
+import { ChatMessage, ChatMessageChunk, } from "./chat.js";
+import { FunctionMessage, FunctionMessageChunk, } from "./function.js";
+import { ToolMessage } from "./tool.js";
+export function coerceMessageLikeToMessage(messageLike) {
+    if (typeof messageLike === "string") {
+        return new HumanMessage(messageLike);
+    }
+    else if (isBaseMessage(messageLike)) {
+        return messageLike;
+    }
+    const [type, content] = messageLike;
+    if (type === "human" || type === "user") {
+        return new HumanMessage({ content });
+    }
+    else if (type === "ai" || type === "assistant") {
+        return new AIMessage({ content });
+    }
+    else if (type === "system") {
+        return new SystemMessage({ content });
+    }
+    else {
+        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.`);
+    }
+}
+/**
+ * This function is used by memory classes to get a string representation
+ * of the chat message history, based on the message content and role.
+ */
+export function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
+    const string_messages = [];
+    for (const m of messages) {
+        let role;
+        if (m._getType() === "human") {
+            role = humanPrefix;
+        }
+        else if (m._getType() === "ai") {
+            role = aiPrefix;
+        }
+        else if (m._getType() === "system") {
+            role = "System";
+        }
+        else if (m._getType() === "function") {
+            role = "Function";
+        }
+        else if (m._getType() === "tool") {
+            role = "Tool";
+        }
+        else if (m._getType() === "generic") {
+            role = m.role;
+        }
+        else {
+            throw new Error(`Got unsupported message type: ${m._getType()}`);
+        }
+        const nameStr = m.name ? `${m.name}, ` : "";
+        string_messages.push(`${role}: ${nameStr}${m.content}`);
+    }
+    return string_messages.join("\n");
+}
+/**
+ * Maps messages from an older format (V1) to the current `StoredMessage`
+ * format. If the message is already in the `StoredMessage` format, it is
+ * returned as is. Otherwise, it transforms the V1 message into a
+ * `StoredMessage`. This function is important for maintaining
+ * compatibility with older message formats.
+ */
+function mapV1MessageToStoredMessage(message) {
+    // TODO: Remove this mapper when we deprecate the old message format.
+    if (message.data !== undefined) {
+        return message;
+    }
+    else {
+        const v1Message = message;
+        return {
+            type: v1Message.type,
+            data: {
+                content: v1Message.text,
+                role: v1Message.role,
+                name: undefined,
+                tool_call_id: undefined,
+            },
+        };
+    }
+}
+export function mapStoredMessageToChatMessage(message) {
+    const storedMessage = mapV1MessageToStoredMessage(message);
+    switch (storedMessage.type) {
+        case "human":
+            return new HumanMessage(storedMessage.data);
+        case "ai":
+            return new AIMessage(storedMessage.data);
+        case "system":
+            return new SystemMessage(storedMessage.data);
+        case "function":
+            if (storedMessage.data.name === undefined) {
+                throw new Error("Name must be defined for function messages");
+            }
+            return new FunctionMessage(storedMessage.data);
+        case "tool":
+            if (storedMessage.data.tool_call_id === undefined) {
+                throw new Error("Tool call ID must be defined for tool messages");
+            }
+            return new ToolMessage(storedMessage.data);
+        case "chat": {
+            if (storedMessage.data.role === undefined) {
+                throw new Error("Role must be defined for chat messages");
+            }
+            return new ChatMessage(storedMessage.data);
+        }
+        default:
+            throw new Error(`Got unexpected type: ${storedMessage.type}`);
+    }
+}
+/**
+ * Transforms an array of `StoredMessage` instances into an array of
+ * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`
+ * function to ensure all messages are in the `StoredMessage` format, then
+ * creates new instances of the appropriate `BaseMessage` subclass based
+ * on the type of each message. This function is used to prepare stored
+ * messages for use in a chat context.
+ */
+export function mapStoredMessagesToChatMessages(messages) {
+    return messages.map(mapStoredMessageToChatMessage);
+}
+/**
+ * Transforms an array of `BaseMessage` instances into an array of
+ * `StoredMessage` instances. It does this by calling the `toDict` method
+ * on each `BaseMessage`, which returns a `StoredMessage`. This function
+ * is used to prepare chat messages for storage.
+ */
+export function mapChatMessagesToStoredMessages(messages) {
+    return messages.map((message) => message.toDict());
+}
+export function convertToChunk(message) {
+    const type = message._getType();
+    if (type === "human") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new HumanMessageChunk({ ...message });
+    }
+    else if (type === "ai") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new AIMessageChunk({ ...message });
+    }
+    else if (type === "system") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new SystemMessageChunk({ ...message });
+    }
+    else if (type === "function") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new FunctionMessageChunk({ ...message });
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    }
+    else if (ChatMessage.isInstance(message)) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new ChatMessageChunk({ ...message });
+    }
+    else {
+        throw new Error("Unknown message type.");
+    }
+}