@langchain/core 0.2.5 → 0.2.7

package/README.md

@@ -1,6 +1,6 @@
 # 🦜🍎️ @langchain/core
 
-[![CI](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml) ![npm](https://img.shields.io/npm/dw/@langchain/core) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai) [![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
+[![CI](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml) ![npm](https://img.shields.io/npm/dm/@langchain/core) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai) [![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
 
 `@langchain/core` contains the core abstractions and schemas of LangChain.js, including base classes for language models,
 chat models, vectorstores, retrievers, and runnables.

package/dist/callbacks/promises.cjs

@@ -20,7 +20,7 @@ function createQueue() {
 }
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promise Promise to consume
+ * @param promiseFn Promise to consume
  * @param wait Whether to wait for the promise to resolve or resolve immediately
  */
 async function consumeCallback(promiseFn, wait) {

package/dist/callbacks/promises.d.ts

@@ -1,6 +1,6 @@
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promise Promise to consume
+ * @param promiseFn Promise to consume
  * @param wait Whether to wait for the promise to resolve or resolve immediately
  */
 export declare function consumeCallback<T>(promiseFn: () => Promise<T> | T | void, wait: boolean): Promise<void>;

package/dist/callbacks/promises.js

@@ -14,7 +14,7 @@ function createQueue() {
 }
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promise Promise to consume
+ * @param promiseFn Promise to consume
  * @param wait Whether to wait for the promise to resolve or resolve immediately
  */
 export async function consumeCallback(promiseFn, wait) {

package/dist/language_models/chat_models.d.ts

@@ -78,7 +78,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
     invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;
     _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;
-    protected getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
+    getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
     /** @ignore */
     _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
     _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }: ChatModelGenerateCachedParameters<typeof this>): Promise<LLMResult & {

package/dist/prompts/chat.cjs

@@ -301,14 +301,20 @@ class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
                 else if (typeof item.text === "string") {
                     text = item.text ?? "";
                 }
-                prompt.push(prompt_js_1.PromptTemplate.fromTemplate(text));
+                prompt.push(prompt_js_1.PromptTemplate.fromTemplate(text, additionalOptions));
             }
             else if (typeof item === "object" && "image_url" in item) {
                 let imgTemplate = item.image_url ?? "";
                 let imgTemplateObject;
                 let inputVariables = [];
                 if (typeof imgTemplate === "string") {
-                    const parsedTemplate = (0, template_js_1.parseFString)(imgTemplate);
+                    let parsedTemplate;
+                    if (additionalOptions?.templateFormat === "mustache") {
+                        parsedTemplate = (0, template_js_1.parseMustache)(imgTemplate);
+                    }
+                    else {
+                        parsedTemplate = (0, template_js_1.parseFString)(imgTemplate);
+                    }
                     const variables = parsedTemplate.flatMap((item) => item.type === "variable" ? [item.name] : []);
                     if ((variables?.length ?? 0) > 0) {
                         if (variables.length > 1) {
@@ -327,7 +333,13 @@ class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
                 }
                 else if (typeof imgTemplate === "object") {
                     if ("url" in imgTemplate) {
-                        const parsedTemplate = (0, template_js_1.parseFString)(imgTemplate.url);
+                        let parsedTemplate;
+                        if (additionalOptions?.templateFormat === "mustache") {
+                            parsedTemplate = (0, template_js_1.parseMustache)(imgTemplate.url);
+                        }
+                        else {
+                            parsedTemplate = (0, template_js_1.parseFString)(imgTemplate.url);
+                        }
                         inputVariables = parsedTemplate.flatMap((item) => item.type === "variable" ? [item.name] : []);
                     }
                     else {
@@ -600,7 +612,9 @@ class ChatPromptTemplate extends BaseChatPromptTemplate {
             else {
                 imageUrl = item.image_url.url;
             }
-            const promptTemplatePlaceholder = prompt_js_1.PromptTemplate.fromTemplate(imageUrl);
+            const promptTemplatePlaceholder = prompt_js_1.PromptTemplate.fromTemplate(imageUrl, {
+                templateFormat: this.templateFormat,
+            });
             const formattedUrl = await promptTemplatePlaceholder.format(inputValues);
             if (typeof item.image_url !== "string" && "url" in item.image_url) {
                 // eslint-disable-next-line no-param-reassign

package/dist/prompts/chat.js

@@ -7,7 +7,7 @@ import { BaseStringPromptTemplate } from "./string.js";
 import { BasePromptTemplate, } from "./base.js";
 import { PromptTemplate, } from "./prompt.js";
 import { ImagePromptTemplate } from "./image.js";
-import { parseFString } from "./template.js";
+import { parseFString, parseMustache, } from "./template.js";
 /**
  * Abstract class that serves as a base for creating message prompt
  * templates. It defines how to format messages for different roles in a
@@ -293,14 +293,20 @@ class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
                 else if (typeof item.text === "string") {
                     text = item.text ?? "";
                 }
-                prompt.push(PromptTemplate.fromTemplate(text));
+                prompt.push(PromptTemplate.fromTemplate(text, additionalOptions));
             }
             else if (typeof item === "object" && "image_url" in item) {
                 let imgTemplate = item.image_url ?? "";
                 let imgTemplateObject;
                 let inputVariables = [];
                 if (typeof imgTemplate === "string") {
-                    const parsedTemplate = parseFString(imgTemplate);
+                    let parsedTemplate;
+                    if (additionalOptions?.templateFormat === "mustache") {
+                        parsedTemplate = parseMustache(imgTemplate);
+                    }
+                    else {
+                        parsedTemplate = parseFString(imgTemplate);
+                    }
                     const variables = parsedTemplate.flatMap((item) => item.type === "variable" ? [item.name] : []);
                     if ((variables?.length ?? 0) > 0) {
                         if (variables.length > 1) {
@@ -319,7 +325,13 @@ class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
                 }
                 else if (typeof imgTemplate === "object") {
                     if ("url" in imgTemplate) {
-                        const parsedTemplate = parseFString(imgTemplate.url);
+                        let parsedTemplate;
+                        if (additionalOptions?.templateFormat === "mustache") {
+                            parsedTemplate = parseMustache(imgTemplate.url);
+                        }
+                        else {
+                            parsedTemplate = parseFString(imgTemplate.url);
+                        }
                         inputVariables = parsedTemplate.flatMap((item) => item.type === "variable" ? [item.name] : []);
                     }
                     else {
@@ -589,7 +601,9 @@ export class ChatPromptTemplate extends BaseChatPromptTemplate {
             else {
                 imageUrl = item.image_url.url;
             }
-            const promptTemplatePlaceholder = PromptTemplate.fromTemplate(imageUrl);
+            const promptTemplatePlaceholder = PromptTemplate.fromTemplate(imageUrl, {
+                templateFormat: this.templateFormat,
+            });
             const formattedUrl = await promptTemplatePlaceholder.format(inputValues);
             if (typeof item.image_url !== "string" && "url" in item.image_url) {
                 // eslint-disable-next-line no-param-reassign

package/dist/prompts/template.cjs

@@ -66,7 +66,9 @@ const mustacheTemplateToNodes = (template) => template.map((temp) => {
         const name = temp[1].includes(".") ? temp[1].split(".")[0] : temp[1];
         return { type: "variable", name };
     }
-    else if (temp[0] === "#") {
+    else if (["#", "&"].includes(temp[0])) {
+        // # represents a section, "&" represents an unescaped variable.
+        // These should both be considered variables.
         return { type: "variable", name: temp[1] };
     }
     else {

package/dist/prompts/template.js

@@ -59,7 +59,9 @@ const mustacheTemplateToNodes = (template) => template.map((temp) => {
         const name = temp[1].includes(".") ? temp[1].split(".")[0] : temp[1];
         return { type: "variable", name };
     }
-    else if (temp[0] === "#") {
+    else if (["#", "&"].includes(temp[0])) {
+        // # represents a section, "&" represents an unescaped variable.
+        // These should both be considered variables.
         return { type: "variable", name: temp[1] };
     }
     else {

package/dist/prompts/tests/chat.mustache.test.js

@@ -2,7 +2,7 @@ import { test, expect } from "@jest/globals";
 import { AIMessage } from "../../messages/ai.js";
 import { HumanMessage } from "../../messages/human.js";
 import { SystemMessage } from "../../messages/system.js";
-import { ChatPromptTemplate } from "../chat.js";
+import { ChatPromptTemplate, HumanMessagePromptTemplate } from "../chat.js";
 test("Test creating a chat prompt template from role string messages", async () => {
     const template = ChatPromptTemplate.fromMessages([
         ["system", "You are a helpful AI bot. Your name is {{name}}."],
@@ -59,3 +59,43 @@ test("Ignores f-string inputs input variables with repeats.", async () => {
         new HumanMessage("This {bar} is a {foo} test {foo}."),
     ]);
 });
+test("Mustache template with image and chat prompts inside one template (fromMessages)", async () => {
+    const template = ChatPromptTemplate.fromMessages([
+        [
+            "human",
+            [
+                {
+                    type: "image_url",
+                    image_url: "{{image_url}}",
+                },
+                {
+                    type: "text",
+                    text: "{{other_var}}",
+                },
+            ],
+        ],
+        ["human", "hello {{name}}"],
+    ], {
+        templateFormat: "mustache",
+    });
+    expect(template.inputVariables.sort()).toEqual([
+        "image_url",
+        "name",
+        "other_var",
+    ]);
+});
+test("Mustache image template with nested URL and chat prompts HumanMessagePromptTemplate.fromTemplate", async () => {
+    const template = HumanMessagePromptTemplate.fromTemplate([
+        {
+            text: "{{name}}",
+        },
+        {
+            image_url: {
+                url: "{{image_url}}",
+            },
+        },
+    ], {
+        templateFormat: "mustache",
+    });
+    expect(template.inputVariables.sort()).toEqual(["image_url", "name"]);
+});

package/dist/prompts/tests/prompt.mustache.test.js

@@ -1,5 +1,6 @@
 import { test, expect } from "@jest/globals";
 import { PromptTemplate } from "../prompt.js";
+import { parseTemplate } from "../template.js";
 test("Single input variable.", async () => {
     const template = "This is a {{foo}} test.";
     const prompt = PromptTemplate.fromTemplate(template, {
@@ -83,3 +84,22 @@ hello
 is a test.`);
     expect(promptWithRepeats.inputVariables).toEqual(["foo"]);
 });
+test("Escaped variables", async () => {
+    const template = `test: {{{text}}}`;
+    const parsed = parseTemplate(template, "mustache");
+    expect(parsed[0]).toStrictEqual({
+        type: "literal",
+        text: "test: ",
+    });
+    expect(parsed[1]).toStrictEqual({
+        type: "variable",
+        name: "text",
+    });
+    const promptTemplate = PromptTemplate.fromTemplate(template, {
+        templateFormat: "mustache",
+    });
+    const result = await promptTemplate.invoke({
+        text: `hello i have a "quote`,
+    });
+    expect(result.value).toBe(`test: hello i have a "quote`);
+});

package/dist/runnables/tests/runnable_stream_events_v2.test.js

@@ -7,7 +7,7 @@ import { RunnableLambda, RunnableMap, RunnablePassthrough, RunnablePick, } from
 import { ChatPromptTemplate } from "../../prompts/chat.js";
 import { FakeChatModel, FakeLLM, FakeListChatModel, FakeRetriever, FakeStreamingLLM, } from "../../utils/testing/index.js";
 import { AIMessage, AIMessageChunk, HumanMessage, SystemMessage, } from "../../messages/index.js";
-import { DynamicStructuredTool, DynamicTool } from "../../tools.js";
+import { DynamicStructuredTool, DynamicTool, tool } from "../../tools.js";
 import { Document } from "../../documents/document.js";
 import { PromptTemplate } from "../../prompts/prompt.js";
 import { GenerationChunk } from "../../outputs.js";
@@ -1748,6 +1748,70 @@ test("Runnable streamEvents method with simple tools", async () => {
         },
     ]);
 });
+test("Runnable streamEvents method with tools that return objects", async () => {
+    const adderFunc = (_params) => {
+        return JSON.stringify({ sum: 3 });
+    };
+    const parameterlessTool = tool(adderFunc, {
+        name: "parameterless",
+    });
+    const events = [];
+    const eventStream = parameterlessTool.streamEvents({}, { version: "v2" });
+    for await (const event of eventStream) {
+        events.push(event);
+    }
+    expect(events).toEqual([
+        {
+            data: { input: {} },
+            event: "on_tool_start",
+            metadata: {},
+            name: "parameterless",
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: {
+                output: JSON.stringify({ sum: 3 }),
+            },
+            event: "on_tool_end",
+            metadata: {},
+            name: "parameterless",
+            run_id: expect.any(String),
+            tags: [],
+        },
+    ]);
+    const adderTool = tool(adderFunc, {
+        name: "with_parameters",
+        description: "A tool that does nothing",
+        schema: z.object({
+            x: z.number(),
+            y: z.number(),
+        }),
+    });
+    const events2 = [];
+    const eventStream2 = adderTool.streamEvents({ x: 1, y: 2 }, { version: "v2" });
+    for await (const event of eventStream2) {
+        events2.push(event);
+    }
+    expect(events2).toEqual([
+        {
+            data: { input: { x: 1, y: 2 } },
+            event: "on_tool_start",
+            metadata: {},
+            name: "with_parameters",
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { output: JSON.stringify({ sum: 3 }) },
+            event: "on_tool_end",
+            metadata: {},
+            name: "with_parameters",
+            run_id: expect.any(String),
+            tags: [],
+        },
+    ]);
+});
 test("Runnable streamEvents method with a retriever", async () => {
     const retriever = new FakeRetriever({
         output: [

package/dist/tools.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
+exports.tool = exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
 const zod_1 = require("zod");
 const manager_js_1 = require("./callbacks/manager.cjs");
 const base_js_1 = require("./language_models/base.cjs");
@@ -233,3 +233,28 @@ class BaseToolkit {
     }
 }
 exports.BaseToolkit = BaseToolkit;
+/**
+ * Creates a new StructuredTool instance with the provided function, name, description, and schema.
+ * @function
+ * @template {ZodAny} RunInput The input schema for the tool.
+ *
+ * @param {RunnableFunc<RunInput, string>} func - The function to invoke when the tool is called.
+ * @param fields - An object containing the following properties:
+ * @param {string} fields.name The name of the tool.
+ * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.
+ * @param {z.ZodObject<any, any, any, any>} fields.schema The Zod schema defining the input for the tool.
+ *
+ * @returns {StructuredTool<RunInput, string>} A new StructuredTool instance.
+ */
+function tool(func, fields) {
+    const schema = fields.schema ??
+        zod_1.z.object({ input: zod_1.z.string().optional() }).transform((obj) => obj.input);
+    const description = fields.description ?? schema.description ?? `${fields.name} tool`;
+    return new DynamicStructuredTool({
+        name: fields.name,
+        description,
+        schema: schema,
+        func: async (input, _runManager, config) => func(input, config),
+    });
+}
+exports.tool = tool;

package/dist/tools.d.ts

@@ -2,7 +2,8 @@ import { z } from "zod";
 import { CallbackManagerForToolRun, Callbacks } from "./callbacks/manager.js";
 import { BaseLangChain, type BaseLangChainParams } from "./language_models/base.js";
 import { type RunnableConfig } from "./runnables/config.js";
-import type { RunnableInterface } from "./runnables/base.js";
+import type { RunnableFunc, RunnableInterface } from "./runnables/base.js";
+type ZodAny = z.ZodObject<any, any, any, any>;
 /**
  * Parameters for the Tool classes.
  */
@@ -17,7 +18,7 @@ export declare class ToolInputParsingException extends Error {
     output?: string;
     constructor(message: string, output?: string);
 }
-export interface StructuredToolInterface<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends RunnableInterface<(z.output<T> extends string ? string : never) | z.input<T>, string> {
+export interface StructuredToolInterface<T extends ZodAny = ZodAny> extends RunnableInterface<(z.output<T> extends string ? string : never) | z.input<T>, string> {
     lc_namespace: string[];
     schema: T | z.ZodEffects<T>;
     /**
@@ -41,7 +42,7 @@ export interface StructuredToolInterface<T extends z.ZodObject<any, any, any, an
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
-export declare abstract class StructuredTool<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends BaseLangChain<(z.output<T> extends string ? string : never) | z.input<T>, string> {
+export declare abstract class StructuredTool<T extends ZodAny = ZodAny> extends BaseLangChain<(z.output<T> extends string ? string : never) | z.input<T>, string> {
     abstract schema: T | z.ZodEffects<T>;
     get lc_namespace(): string[];
     constructor(fields?: ToolParams);
@@ -122,7 +123,7 @@ export interface DynamicToolInput extends BaseDynamicToolInput {
 /**
  * Interface for the input parameters of the DynamicStructuredTool class.
  */
-export interface DynamicStructuredToolInput<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends BaseDynamicToolInput {
+export interface DynamicStructuredToolInput<T extends ZodAny = ZodAny> extends BaseDynamicToolInput {
     func: (input: z.infer<T>, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<string>;
     schema: T;
 }
@@ -148,11 +149,11 @@ export declare class DynamicTool extends Tool {
  * StructuredTool class and overrides the _call method to execute the
  * provided function when the tool is called.
  */
-export declare class DynamicStructuredTool<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends StructuredTool {
+export declare class DynamicStructuredTool<T extends ZodAny = ZodAny> extends StructuredTool<T> {
     static lc_name(): string;
     name: string;
     description: string;
-    func: DynamicStructuredToolInput["func"];
+    func: DynamicStructuredToolInput<T>["func"];
     schema: T;
     constructor(fields: DynamicStructuredToolInput<T>);
     /**
@@ -172,3 +173,40 @@ export declare abstract class BaseToolkit {
     abstract tools: StructuredToolInterface[];
     getTools(): StructuredToolInterface[];
 }
+/**
+ * Parameters for the tool function.
+ * @template {ZodAny} RunInput The input schema for the tool.
+ */
+interface ToolWrapperParams<RunInput extends ZodAny = ZodAny> extends ToolParams {
+    /**
+     * The name of the tool. If using with an LLM, this
+     * will be passed as the tool name.
+     */
+    name: string;
+    /**
+     * The description of the tool.
+     * @default `${fields.name} tool`
+     */
+    description?: string;
+    /**
+     * The input schema for the tool. If using an LLM, this
+     * will be passed as the tool schema to generate arguments
+     * for.
+     */
+    schema?: RunInput;
+}
+/**
+ * Creates a new StructuredTool instance with the provided function, name, description, and schema.
+ * @function
+ * @template {ZodAny} RunInput The input schema for the tool.
+ *
+ * @param {RunnableFunc<RunInput, string>} func - The function to invoke when the tool is called.
+ * @param fields - An object containing the following properties:
+ * @param {string} fields.name The name of the tool.
+ * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.
+ * @param {z.ZodObject<any, any, any, any>} fields.schema The Zod schema defining the input for the tool.
+ *
+ * @returns {StructuredTool<RunInput, string>} A new StructuredTool instance.
+ */
+export declare function tool<RunInput extends ZodAny = ZodAny>(func: RunnableFunc<z.infer<RunInput>, string>, fields: ToolWrapperParams<RunInput>): DynamicStructuredTool<RunInput>;
+export {};

package/dist/tools.js

@@ -224,3 +224,27 @@ export class BaseToolkit {
         return this.tools;
     }
 }
+/**
+ * Creates a new StructuredTool instance with the provided function, name, description, and schema.
+ * @function
+ * @template {ZodAny} RunInput The input schema for the tool.
+ *
+ * @param {RunnableFunc<RunInput, string>} func - The function to invoke when the tool is called.
+ * @param fields - An object containing the following properties:
+ * @param {string} fields.name The name of the tool.
+ * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.
+ * @param {z.ZodObject<any, any, any, any>} fields.schema The Zod schema defining the input for the tool.
+ *
+ * @returns {StructuredTool<RunInput, string>} A new StructuredTool instance.
+ */
+export function tool(func, fields) {
+    const schema = fields.schema ??
+        z.object({ input: z.string().optional() }).transform((obj) => obj.input);
+    const description = fields.description ?? schema.description ?? `${fields.name} tool`;
+    return new DynamicStructuredTool({
+        name: fields.name,
+        description,
+        schema: schema,
+        func: async (input, _runManager, config) => func(input, config),
+    });
+}

package/package.json

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