@langchain/core 0.2.6 → 0.2.7

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/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.6",
+  "version": "0.2.7",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {