@langchain/core 0.2.0-rc.0 → 0.2.1

package/dist/language_models/chat_models.cjs

@@ -70,7 +70,11 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             const prompt = BaseChatModel._convertInputToPromptValue(input);
             const messages = prompt.toChatMessages();
             const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
-            const callbackManager_ = await manager_js_1.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+            const inheritableMetadata = {
+                ...runnableConfig.metadata,
+                ...this.getLsParams(callOptions),
+            };
+            const callbackManager_ = await manager_js_1.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
             const extra = {
                 options: callOptions,
                 invocation_params: this?.invocationParams(callOptions),
@@ -103,11 +107,21 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             })));
         }
     }
+    getLsParams(options) {
+        return {
+            ls_model_type: "chat",
+            ls_stop: options.stop,
+        };
+    }
     /** @ignore */
     async _generateUncached(messages, parsedOptions, handledOptions) {
         const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
+        const inheritableMetadata = {
+            ...handledOptions.metadata,
+            ...this.getLsParams(parsedOptions),
+        };
         // create callback manager and start run
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
@@ -164,8 +178,12 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
     }
     async _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }) {
         const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
+        const inheritableMetadata = {
+            ...handledOptions.metadata,
+            ...this.getLsParams(parsedOptions),
+        };
         // create callback manager and start run
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),

package/dist/language_models/chat_models.d.ts

@@ -6,7 +6,7 @@ import { type CallbackManagerForLLMRun, type Callbacks } from "../callbacks/mana
 import type { RunnableConfig } from "../runnables/config.js";
 import type { BaseCache } from "../caches.js";
 import { StructuredToolInterface } from "../tools.js";
-import { RunnableInterface } from "../runnables/types.js";
+import { Runnable } from "../runnables/base.js";
 /**
  * Represents a serialized chat model.
  */
@@ -35,6 +35,14 @@ export type BaseChatModelCallOptions = BaseLanguageModelCallOptions;
  * @returns A TransformStream instance that encodes chat message chunks.
  */
 export declare function createChatMessageChunkEncoderStream(): TransformStream<BaseMessageChunk, any>;
+export type LangSmithParams = {
+    ls_provider?: string;
+    ls_model_name?: string;
+    ls_model_type: "chat";
+    ls_temperature?: number;
+    ls_max_tokens?: number;
+    ls_stop?: Array<string>;
+};
 interface ChatModelGenerateCachedParameters<T extends BaseChatModel<CallOptions>, CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> {
     messages: BaseMessageLike[][];
     cache: BaseCache<Generation[]>;
@@ -60,7 +68,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
      * specific tool schema.
      * @param kwargs Any additional parameters to bind.
      */
-    bindTools?(tools: (StructuredToolInterface | Record<string, unknown>)[], kwargs?: Partial<CallOptions>): RunnableInterface<BaseLanguageModelInput, OutputMessageType, CallOptions>;
+    bindTools?(tools: (StructuredToolInterface | Record<string, unknown>)[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;
     /**
      * Invokes the chat model with a single input.
      * @param input The input for the language model.
@@ -70,6 +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;
     /** @ignore */
     _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
     _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }: ChatModelGenerateCachedParameters<typeof this>): Promise<LLMResult & {

package/dist/language_models/chat_models.js

@@ -66,7 +66,11 @@ export class BaseChatModel extends BaseLanguageModel {
             const prompt = BaseChatModel._convertInputToPromptValue(input);
             const messages = prompt.toChatMessages();
             const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
-            const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+            const inheritableMetadata = {
+                ...runnableConfig.metadata,
+                ...this.getLsParams(callOptions),
+            };
+            const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
             const extra = {
                 options: callOptions,
                 invocation_params: this?.invocationParams(callOptions),
@@ -99,11 +103,21 @@ export class BaseChatModel extends BaseLanguageModel {
             })));
         }
     }
+    getLsParams(options) {
+        return {
+            ls_model_type: "chat",
+            ls_stop: options.stop,
+        };
+    }
     /** @ignore */
     async _generateUncached(messages, parsedOptions, handledOptions) {
         const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
+        const inheritableMetadata = {
+            ...handledOptions.metadata,
+            ...this.getLsParams(parsedOptions),
+        };
         // create callback manager and start run
-        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
@@ -160,8 +174,12 @@ export class BaseChatModel extends BaseLanguageModel {
     }
     async _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }) {
         const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
+        const inheritableMetadata = {
+            ...handledOptions.metadata,
+            ...this.getLsParams(parsedOptions),
+        };
         // create callback manager and start run
-        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),

package/dist/language_models/tests/chat_models.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/language_models/tests/chat_models.test.js

@@ -0,0 +1,154 @@
+/* eslint-disable no-promise-executor-return */
+import { test } from "@jest/globals";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { FakeChatModel, FakeListChatModel } from "../../utils/testing/index.js";
+test("Test ChatModel uses callbacks", async () => {
+    const model = new FakeChatModel({});
+    let acc = "";
+    const response = await model.invoke("Hello there!", {
+        callbacks: [
+            {
+                handleLLMNewToken: (token) => {
+                    console.log(token);
+                    acc += token;
+                },
+            },
+        ],
+    });
+    expect(response.content).toEqual(acc);
+});
+test("Test ChatModel uses callbacks with a cache", async () => {
+    const model = new FakeChatModel({
+        cache: true,
+    });
+    let acc = "";
+    const response = await model.invoke("Hello there!");
+    const response2 = await model.invoke("Hello there!", {
+        callbacks: [
+            {
+                handleLLMNewToken: (token) => {
+                    console.log(token);
+                    acc += token;
+                },
+            },
+        ],
+    });
+    // If callbacks are backgrounded
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    expect(response.content).toEqual(response2.content);
+    expect(response2.content).toEqual(acc);
+});
+test("Test ChatModel legacy params withStructuredOutput", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput({
+        includeRaw: false,
+        schema: z.object({
+            test: z.boolean(),
+            nested: z.object({
+                somethingelse: z.string(),
+            }),
+        }),
+    });
+    const response = await model.invoke("Hello there!");
+    // @ts-expect-error not in run output type
+    console.log(response.notthere);
+    console.log(response.nested.somethingelse);
+    expect(response).toEqual({
+        test: true,
+        nested: { somethingelse: "somevalue" },
+    });
+});
+// test("Test ChatModel legacy params includeRaw withStructuredOutput", async () => {
+//   const model = new FakeListChatModel({
+//     responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+//   }).withStructuredOutput({
+//     includeRaw: true,
+//     schema: z.object({
+//       test: z.boolean(),
+//       nested: z.object({
+//         somethingelse: z.string(),
+//       }),
+//     }),
+//   });
+//   const response = await model.invoke("Hello there!");
+//   // @ts-expect-error legacy
+//   console.log(response.nested);
+//   console.log(response.parsed.nested);
+// });
+test("Test ChatModel withStructuredOutput with supplied type arg", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput({
+        includeRaw: false,
+        schema: z.object({
+            test: z.boolean(),
+            nested: z.object({
+                somethingelse: z.string(),
+            }),
+        }),
+    });
+    const response = await model.invoke("Hello there!");
+    // @ts-expect-error run output type forced to something else
+    console.log(response.nested.somethingelse);
+    // No error here
+    console.log(response.forcedArg);
+    expect(response).toEqual({
+        test: true,
+        nested: { somethingelse: "somevalue" },
+    });
+});
+test("Test ChatModel withStructuredOutput new syntax", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput(z.object({
+        test: z.boolean(),
+        nested: z.object({
+            somethingelse: z.string(),
+        }),
+    }));
+    const response = await model.invoke("Hello there!");
+    // @ts-expect-error run output type forced to something else
+    console.log(response.nested.somethingelse);
+    // No error here
+    console.log(response.forcedArg);
+    expect(response).toEqual({
+        test: true,
+        nested: { somethingelse: "somevalue" },
+    });
+});
+test("Test ChatModel withStructuredOutput new syntax and JSON schema", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput(zodToJsonSchema(z.object({
+        test: z.boolean(),
+        nested: z.object({
+            somethingelse: z.string(),
+        }),
+    })));
+    const response = await model.invoke("Hello there!");
+    // No error here
+    console.log(response.nested.somethingelse);
+    // Also no error here
+    console.log(response.forcedArg);
+    expect(response).toEqual({
+        test: true,
+        nested: { somethingelse: "somevalue" },
+    });
+});
+test("Test ChatModel withStructuredOutput new syntax and includeRaw", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput(z.object({
+        test: z.boolean(),
+        nested: z.object({
+            somethingelse: z.string(),
+        }),
+    }), { includeRaw: true });
+    const response = await model.invoke("Hello there!");
+    // @ts-expect-error run output includes raw
+    console.log(response.nested.somethingelse);
+    // No error
+    console.log(response.parsed);
+});

package/dist/language_models/tests/count_tokens.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/language_models/tests/count_tokens.test.js

@@ -0,0 +1,19 @@
+import { test, expect } from "@jest/globals";
+import { calculateMaxTokens, getModelContextSize } from "../base.js";
+test("properly calculates correct max tokens", async () => {
+    expect(await calculateMaxTokens({ prompt: "", modelName: "gpt-3.5-turbo-16k" })).toBe(16384);
+    expect(await calculateMaxTokens({
+        prompt: "",
+        modelName: "gpt-3.5-turbo-16k-0613",
+    })).toBe(16384);
+    expect(await calculateMaxTokens({ prompt: "", modelName: "gpt-3.5-turbo" })).toBe(4096);
+    expect(await calculateMaxTokens({ prompt: "", modelName: "gpt-4" })).toBe(8192);
+    expect(await calculateMaxTokens({ prompt: "", modelName: "gpt-4-32k" })).toBe(32768);
+});
+test("properly gets model context size", async () => {
+    expect(await getModelContextSize("gpt-3.5-turbo-16k")).toBe(16384);
+    expect(await getModelContextSize("gpt-3.5-turbo-16k-0613")).toBe(16384);
+    expect(await getModelContextSize("gpt-3.5-turbo")).toBe(4096);
+    expect(await getModelContextSize("gpt-4")).toBe(8192);
+    expect(await getModelContextSize("gpt-4-32k")).toBe(32768);
+});

package/dist/language_models/tests/llms.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/language_models/tests/llms.test.js

@@ -0,0 +1,39 @@
+/* eslint-disable no-promise-executor-return */
+import { test } from "@jest/globals";
+import { FakeLLM } from "../../utils/testing/index.js";
+test("Test FakeLLM uses callbacks", async () => {
+    const model = new FakeLLM({});
+    let acc = "";
+    const response = await model.invoke("Hello there!", {
+        callbacks: [
+            {
+                handleLLMNewToken: (token) => {
+                    console.log(token);
+                    acc += token;
+                },
+            },
+        ],
+    });
+    expect(response).toEqual(acc);
+});
+test("Test FakeLLM uses callbacks with a cache", async () => {
+    const model = new FakeLLM({
+        cache: true,
+    });
+    let acc = "";
+    const response = await model.invoke("Hello there!");
+    const response2 = await model.invoke("Hello there!", {
+        callbacks: [
+            {
+                handleLLMNewToken: (token) => {
+                    console.log(token);
+                    acc += token;
+                },
+            },
+        ],
+    });
+    // If callbacks are backgrounded
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    expect(response).toEqual(response2);
+    expect(response2).toEqual(acc);
+});

package/dist/messages/tests/base_message.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/messages/tests/base_message.test.js

@@ -0,0 +1,97 @@
+import { test } from "@jest/globals";
+import { ChatPromptTemplate } from "../../prompts/chat.js";
+import { HumanMessage, AIMessage, ToolMessage } from "../index.js";
+import { load } from "../../load/index.js";
+test("Test ChatPromptTemplate can format OpenAI content image messages", async () => {
+    const message = new HumanMessage({
+        content: [
+            {
+                type: "image_url",
+                image_url: {
+                    url: `data:image/jpeg;base64,{image_string}`,
+                },
+            },
+        ],
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        message,
+        ["ai", "Will this format with multiple messages?: {yes_or_no}"],
+    ]);
+    const formatted = await prompt.invoke({
+        image_string: "base_64_encoded_string",
+        yes_or_no: "YES!",
+    });
+    expect(formatted.messages[0].content[0]).toEqual({
+        type: "image_url",
+        image_url: {
+            url: "data:image/jpeg;base64,base_64_encoded_string",
+        },
+    });
+    expect(formatted.messages[1].content).toEqual("Will this format with multiple messages?: YES!");
+});
+test("Test ChatPromptTemplate can format OpenAI content image messages", async () => {
+    const message = new HumanMessage({
+        content: [
+            {
+                type: "image_url",
+                image_url: {
+                    url: `data:image/jpeg;base64,{image_string}`,
+                },
+            },
+        ],
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        message,
+        ["ai", "Will this format with multiple messages?: {yes_or_no}"],
+    ]);
+    const formatted = await prompt.invoke({
+        image_string: "base_64_encoded_string",
+        yes_or_no: "YES!",
+    });
+    expect(formatted.messages[0].content[0]).toEqual({
+        type: "image_url",
+        image_url: {
+            url: "data:image/jpeg;base64,base_64_encoded_string",
+        },
+    });
+    expect(formatted.messages[1].content).toEqual("Will this format with multiple messages?: YES!");
+});
+test("Deserialisation and serialisation of additional_kwargs and tool_call_id", async () => {
+    const config = {
+        importMap: { messages: { AIMessage } },
+        optionalImportEntrypoints: [],
+        optionalImportsMap: {},
+        secretsMap: {},
+    };
+    const message = new AIMessage({
+        content: "",
+        additional_kwargs: {
+            tool_calls: [
+                {
+                    id: "call_tXJNP1S6LHT5tLfaNHCbYCtH",
+                    type: "function",
+                    function: {
+                        name: "Weather",
+                        arguments: '{\n  "location": "Prague"\n}',
+                    },
+                },
+            ],
+        },
+    });
+    const deserialized = await load(JSON.stringify(message), config);
+    expect(deserialized).toEqual(message);
+});
+test("Deserialisation and serialisation of tool_call_id", async () => {
+    const config = {
+        importMap: { messages: { ToolMessage } },
+        optionalImportEntrypoints: [],
+        optionalImportsMap: {},
+        secretsMap: {},
+    };
+    const message = new ToolMessage({
+        content: '{"value": 32}',
+        tool_call_id: "call_tXJNP1S6LHT5tLfaNHCbYCtH",
+    });
+    const deserialized = await load(JSON.stringify(message), config);
+    expect(deserialized).toEqual(message);
+});

package/dist/output_parsers/openai_tools/tests/json_output_tools_parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/output_parsers/openai_tools/tests/json_output_tools_parser.test.js

@@ -0,0 +1,81 @@
+import { test } from "@jest/globals";
+import { z } from "zod";
+import { JsonOutputKeyToolsParser } from "../json_output_tools_parsers.js";
+import { AIMessage } from "../../../messages/index.js";
+import { OutputParserException } from "../../base.js";
+test("JSONOutputKeyToolsParser invoke", async () => {
+    const outputParser = new JsonOutputKeyToolsParser({
+        keyName: "testing",
+        returnSingle: true,
+    });
+    const result = await outputParser.invoke(new AIMessage({
+        content: "",
+        additional_kwargs: {
+            tool_calls: [
+                {
+                    id: "test",
+                    type: "function",
+                    function: {
+                        name: "testing",
+                        arguments: JSON.stringify({ testKey: 9 }),
+                    },
+                },
+            ],
+        },
+    }));
+    expect(result).toEqual({ testKey: 9 });
+});
+test("JSONOutputKeyToolsParser with a passed schema throws", async () => {
+    const outputParser = new JsonOutputKeyToolsParser({
+        keyName: "testing",
+        returnSingle: true,
+        zodSchema: z.object({
+            testKey: z.string(),
+        }),
+    });
+    try {
+        await outputParser.invoke(new AIMessage({
+            content: "",
+            additional_kwargs: {
+                tool_calls: [
+                    {
+                        id: "test",
+                        type: "function",
+                        function: {
+                            name: "testing",
+                            arguments: JSON.stringify({ testKey: 9 }),
+                        },
+                    },
+                ],
+            },
+        }));
+    }
+    catch (e) {
+        expect(e).toBeInstanceOf(OutputParserException);
+    }
+});
+test("JSONOutputKeyToolsParser can validate a proper input", async () => {
+    const outputParser = new JsonOutputKeyToolsParser({
+        keyName: "testing",
+        returnSingle: true,
+        zodSchema: z.object({
+            testKey: z.string(),
+        }),
+    });
+    const result = await outputParser.invoke(new AIMessage({
+        content: "",
+        additional_kwargs: {
+            tool_calls: [
+                {
+                    id: "test",
+                    type: "function",
+                    function: {
+                        name: "testing",
+                        arguments: JSON.stringify({ testKey: "testval" }),
+                    },
+                },
+            ],
+        },
+    }));
+    expect(result).toEqual({ testKey: "testval" });
+});

package/dist/output_parsers/tests/json.test.d.ts

@@ -0,0 +1 @@
+export {};