langchain 0.1.2 → 0.1.4

package/dist/output_parsers/openai_tools.cjs

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonOutputToolsParser = void 0;
+exports.JsonOutputKeyToolsParser = exports.JsonOutputToolsParser = void 0;
 const output_parsers_1 = require("@langchain/core/output_parsers");
 /**
- * Class for parsing the output of an LLM into a JSON object. Uses an
- * instance of `OutputToolsParser` to parse the output.
+ * Class for parsing the output of a tool-calling LLM into a JSON object.
  */
 class JsonOutputToolsParser extends output_parsers_1.BaseLLMOutputParser {
-    constructor() {
-        super(...arguments);
+    static lc_name() {
+        return "JsonOutputToolsParser";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "returnId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -21,9 +29,7 @@ class JsonOutputToolsParser extends output_parsers_1.BaseLLMOutputParser {
             writable: true,
             value: true
         });
-    }
-    static lc_name() {
-        return "JsonOutputToolsParser";
+        this.returnId = fields?.returnId ?? this.returnId;
     }
     /**
      * Parses the output and returns a JSON object. If `argsOnly` is true,
@@ -45,6 +51,9 @@ class JsonOutputToolsParser extends output_parsers_1.BaseLLMOutputParser {
                     type: toolCall.function.name,
                     args: JSON.parse(toolCall.function.arguments),
                 };
+                if (this.returnId) {
+                    parsedToolCall.id = toolCall.id;
+                }
                 // backward-compatibility with previous
                 // versions of Langchain JS, which uses `name` and `arguments`
                 Object.defineProperty(parsedToolCall, "name", {
@@ -64,3 +73,72 @@ class JsonOutputToolsParser extends output_parsers_1.BaseLLMOutputParser {
     }
 }
 exports.JsonOutputToolsParser = JsonOutputToolsParser;
+/**
+ * Class for parsing the output of a tool-calling LLM into a JSON object if you are
+ * expecting only a single tool to be called.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class JsonOutputKeyToolsParser extends output_parsers_1.BaseLLMOutputParser {
+    static lc_name() {
+        return "JsonOutputKeyToolsParser";
+    }
+    constructor(params) {
+        super(params);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "openai_tools"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "returnId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** The type of tool calls to return. */
+        Object.defineProperty(this, "keyName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether to return only the first tool call. */
+        Object.defineProperty(this, "returnSingle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "initialParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keyName = params.keyName;
+        this.returnSingle = params.returnSingle ?? this.returnSingle;
+        this.initialParser = new JsonOutputToolsParser(params);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parseResult(generations) {
+        const results = await this.initialParser.parseResult(generations);
+        const matchingResults = results.filter((result) => result.type === this.keyName);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let returnedValues = matchingResults;
+        if (!this.returnId) {
+            returnedValues = matchingResults.map((result) => result.args);
+        }
+        if (this.returnSingle) {
+            return returnedValues[0];
+        }
+        return returnedValues;
+    }
+}
+exports.JsonOutputKeyToolsParser = JsonOutputKeyToolsParser;

package/dist/output_parsers/openai_tools.d.ts

@@ -1,6 +1,7 @@
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import type { ChatGeneration } from "@langchain/core/outputs";
 export type ParsedToolCall = {
+    id?: string;
     type: string;
     args: Record<string, any>;
     /** @deprecated Use `type` instead. Will be removed in 0.2.0. */
@@ -8,14 +9,19 @@ export type ParsedToolCall = {
     /** @deprecated Use `args` instead. Will be removed in 0.2.0. */
     arguments: Record<string, any>;
 };
+export type JsonOutputToolsParserParams = {
+    /** Whether to return the tool call id. */
+    returnId?: boolean;
+};
 /**
- * Class for parsing the output of an LLM into a JSON object. Uses an
- * instance of `OutputToolsParser` to parse the output.
+ * Class for parsing the output of a tool-calling LLM into a JSON object.
  */
 export declare class JsonOutputToolsParser extends BaseLLMOutputParser<ParsedToolCall[]> {
     static lc_name(): string;
+    returnId: boolean;
     lc_namespace: string[];
     lc_serializable: boolean;
+    constructor(fields?: JsonOutputToolsParserParams);
     /**
      * Parses the output and returns a JSON object. If `argsOnly` is true,
      * only the arguments of the function call are returned.
@@ -24,3 +30,26 @@ export declare class JsonOutputToolsParser extends BaseLLMOutputParser<ParsedToo
      */
     parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]>;
 }
+export type JsonOutputKeyToolsParserParams = {
+    keyName: string;
+    returnSingle?: boolean;
+    /** Whether to return the tool call id. */
+    returnId?: boolean;
+};
+/**
+ * Class for parsing the output of a tool-calling LLM into a JSON object if you are
+ * expecting only a single tool to be called.
+ */
+export declare class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    returnId: boolean;
+    /** The type of tool calls to return. */
+    keyName: string;
+    /** Whether to return only the first tool call. */
+    returnSingle: boolean;
+    initialParser: JsonOutputToolsParser;
+    constructor(params: JsonOutputKeyToolsParserParams);
+    parseResult(generations: ChatGeneration[]): Promise<any>;
+}

package/dist/output_parsers/openai_tools.js

@@ -1,11 +1,19 @@
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 /**
- * Class for parsing the output of an LLM into a JSON object. Uses an
- * instance of `OutputToolsParser` to parse the output.
+ * Class for parsing the output of a tool-calling LLM into a JSON object.
  */
 export class JsonOutputToolsParser extends BaseLLMOutputParser {
-    constructor() {
-        super(...arguments);
+    static lc_name() {
+        return "JsonOutputToolsParser";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "returnId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -18,9 +26,7 @@ export class JsonOutputToolsParser extends BaseLLMOutputParser {
             writable: true,
             value: true
         });
-    }
-    static lc_name() {
-        return "JsonOutputToolsParser";
+        this.returnId = fields?.returnId ?? this.returnId;
     }
     /**
      * Parses the output and returns a JSON object. If `argsOnly` is true,
@@ -42,6 +48,9 @@ export class JsonOutputToolsParser extends BaseLLMOutputParser {
                     type: toolCall.function.name,
                     args: JSON.parse(toolCall.function.arguments),
                 };
+                if (this.returnId) {
+                    parsedToolCall.id = toolCall.id;
+                }
                 // backward-compatibility with previous
                 // versions of Langchain JS, which uses `name` and `arguments`
                 Object.defineProperty(parsedToolCall, "name", {
@@ -60,3 +69,71 @@ export class JsonOutputToolsParser extends BaseLLMOutputParser {
         return parsedToolCalls;
     }
 }
+/**
+ * Class for parsing the output of a tool-calling LLM into a JSON object if you are
+ * expecting only a single tool to be called.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class JsonOutputKeyToolsParser extends BaseLLMOutputParser {
+    static lc_name() {
+        return "JsonOutputKeyToolsParser";
+    }
+    constructor(params) {
+        super(params);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "openai_tools"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "returnId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** The type of tool calls to return. */
+        Object.defineProperty(this, "keyName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether to return only the first tool call. */
+        Object.defineProperty(this, "returnSingle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "initialParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keyName = params.keyName;
+        this.returnSingle = params.returnSingle ?? this.returnSingle;
+        this.initialParser = new JsonOutputToolsParser(params);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parseResult(generations) {
+        const results = await this.initialParser.parseResult(generations);
+        const matchingResults = results.filter((result) => result.type === this.keyName);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let returnedValues = matchingResults;
+        if (!this.returnId) {
+            returnedValues = matchingResults.map((result) => result.args);
+        }
+        if (this.returnSingle) {
+            return returnedValues[0];
+        }
+        return returnedValues;
+    }
+}

package/dist/output_parsers/structured.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { zodToJsonSchema, } from "zod-to-json-schema";
 import { BaseOutputParser, OutputParserException, } from "@langchain/core/output_parsers";
 export class StructuredOutputParser extends BaseOutputParser {
     static lc_name() {

package/dist/runnables/remote.cjs

@@ -4,7 +4,9 @@ exports.RemoteRunnable = void 0;
 const runnables_1 = require("@langchain/core/runnables");
 const documents_1 = require("@langchain/core/documents");
 const prompt_values_1 = require("@langchain/core/prompt_values");
+const log_stream_1 = require("@langchain/core/tracers/log_stream");
 const messages_1 = require("@langchain/core/messages");
+const outputs_1 = require("@langchain/core/outputs");
 const event_source_parse_1 = require("@langchain/community/utils/event_source_parse");
 const stream_1 = require("@langchain/core/utils/stream");
 function isSuperset(set, subset) {
@@ -20,94 +22,153 @@ function revive(obj) {
     if (Array.isArray(obj))
         return obj.map(revive);
     if (typeof obj === "object") {
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!obj || obj instanceof Date) {
+            return obj;
+        }
         const keysArr = Object.keys(obj);
         const keys = new Set(keysArr);
-        if (isSuperset(keys, new Set(["page_content", "metadata"])))
+        if (isSuperset(keys, new Set(["page_content", "metadata"]))) {
             return new documents_1.Document({
                 pageContent: obj.page_content,
                 metadata: obj.metadata,
             });
-        if (isSuperset(keys, new Set(["content", "type", "is_chunk"]))) {
-            if (!obj.is_chunk) {
-                if (obj.type === "human") {
-                    return new messages_1.HumanMessage({
-                        content: obj.content,
-                    });
-                }
-                if (obj.type === "system") {
-                    return new messages_1.SystemMessage({
-                        content: obj.content,
-                    });
-                }
-                if (obj.type === "chat") {
-                    return new messages_1.ChatMessage({
-                        content: obj.content,
-                        role: obj.role,
-                    });
-                }
-                if (obj.type === "function") {
-                    return new messages_1.FunctionMessage({
-                        content: obj.content,
-                        name: obj.name,
-                    });
-                }
-                if (obj.type === "tool") {
-                    return new messages_1.ToolMessage({
-                        content: obj.content,
-                        tool_call_id: obj.tool_call_id,
-                    });
-                }
-                if (obj.type === "ai") {
-                    return new messages_1.AIMessage({
-                        content: obj.content,
-                    });
-                }
-            }
-            else {
-                if (obj.type === "human") {
-                    return new messages_1.HumanMessageChunk({
-                        content: obj.content,
-                    });
-                }
-                if (obj.type === "system") {
-                    return new messages_1.SystemMessageChunk({
-                        content: obj.content,
-                    });
-                }
-                if (obj.type === "chat") {
-                    return new messages_1.ChatMessageChunk({
-                        content: obj.content,
-                        role: obj.role,
-                    });
-                }
-                if (obj.type === "function") {
-                    return new messages_1.FunctionMessageChunk({
-                        content: obj.content,
-                        name: obj.name,
-                    });
-                }
-                if (obj.type === "tool") {
-                    return new messages_1.ToolMessageChunk({
-                        content: obj.content,
-                        tool_call_id: obj.tool_call_id,
-                    });
-                }
-                if (obj.type === "ai") {
-                    return new messages_1.AIMessageChunk({
-                        content: obj.content,
-                    });
-                }
+        }
+        if (isSuperset(keys, new Set(["content", "type", "additional_kwargs"]))) {
+            if (obj.type === "HumanMessage" || obj.type === "human") {
+                return new messages_1.HumanMessage({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "SystemMessage" || obj.type === "system") {
+                return new messages_1.SystemMessage({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "ChatMessage" || obj.type === "chat") {
+                return new messages_1.ChatMessage({
+                    content: obj.content,
+                    role: obj.role,
+                });
+            }
+            if (obj.type === "FunctionMessage" || obj.type === "function") {
+                return new messages_1.FunctionMessage({
+                    content: obj.content,
+                    name: obj.name,
+                });
+            }
+            if (obj.type === "ToolMessage" || obj.type === "tool") {
+                return new messages_1.ToolMessage({
+                    content: obj.content,
+                    tool_call_id: obj.tool_call_id,
+                });
+            }
+            if (obj.type === "AIMessage" || obj.type === "ai") {
+                return new messages_1.AIMessage({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "HumanMessageChunk") {
+                return new messages_1.HumanMessageChunk({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "SystemMessageChunk") {
+                return new messages_1.SystemMessageChunk({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "ChatMessageChunk") {
+                return new messages_1.ChatMessageChunk({
+                    content: obj.content,
+                    role: obj.role,
+                });
+            }
+            if (obj.type === "FunctionMessageChunk") {
+                return new messages_1.FunctionMessageChunk({
+                    content: obj.content,
+                    name: obj.name,
+                });
+            }
+            if (obj.type === "ToolMessageChunk") {
+                return new messages_1.ToolMessageChunk({
+                    content: obj.content,
+                    tool_call_id: obj.tool_call_id,
+                });
+            }
+            if (obj.type === "AIMessageChunk") {
+                return new messages_1.AIMessageChunk({
+                    content: obj.content,
+                });
             }
         }
-        if (isSuperset(keys, new Set(["text"]))) {
-            return new prompt_values_1.StringPromptValue(obj.text);
+        if (isSuperset(keys, new Set(["text", "generation_info", "type"]))) {
+            if (obj.type === "ChatGenerationChunk") {
+                return new outputs_1.ChatGenerationChunk({
+                    message: revive(obj.message),
+                    text: obj.text,
+                    generationInfo: obj.generation_info,
+                });
+            }
+            else if (obj.type === "ChatGeneration") {
+                return {
+                    message: revive(obj.message),
+                    text: obj.text,
+                    generationInfo: obj.generation_info,
+                };
+            }
+            else if (obj.type === "GenerationChunk") {
+                return new outputs_1.GenerationChunk({
+                    text: obj.text,
+                    generationInfo: obj.generation_info,
+                });
+            }
+            else if (obj.type === "Generation") {
+                return {
+                    text: obj.text,
+                    generationInfo: obj.generation_info,
+                };
+            }
+        }
+        if (isSuperset(keys, new Set(["tool", "tool_input", "log", "type"]))) {
+            if (obj.type === "AgentAction") {
+                return {
+                    tool: obj.tool,
+                    toolInput: obj.tool_input,
+                    log: obj.log,
+                };
+            }
+        }
+        if (isSuperset(keys, new Set(["return_values", "log", "type"]))) {
+            if (obj.type === "AgentFinish") {
+                return {
+                    returnValues: obj.return_values,
+                    log: obj.log,
+                };
+            }
+        }
+        if (isSuperset(keys, new Set(["generations", "run", "type"]))) {
+            if (obj.type === "LLMResult") {
+                return {
+                    generations: revive(obj.generations),
+                    llmOutput: obj.llm_output,
+                    [outputs_1.RUN_KEY]: obj.run,
+                };
+            }
         }
         if (isSuperset(keys, new Set(["messages"]))) {
+            // TODO: Start checking for type: ChatPromptValue and ChatPromptValueConcrete
+            // when LangServe bug is fixed
             return new prompt_values_1.ChatPromptValue({
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 messages: obj.messages.map((msg) => revive(msg)),
             });
         }
+        if (isSuperset(keys, new Set(["text"]))) {
+            // TODO: Start checking for type: StringPromptValue
+            // when LangServe bug is fixed
+            return new prompt_values_1.StringPromptValue(obj.text);
+        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const innerRevive = (key) => [
             key,
@@ -232,5 +293,48 @@ class RemoteRunnable extends runnables_1.Runnable {
         });
         return stream_1.IterableReadableStream.fromReadableStream(stream);
     }
+    async *streamLog(input, options, streamOptions) {
+        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
+        const stream = new log_stream_1.LogStreamCallbackHandler({
+            ...streamOptions,
+            autoClose: false,
+        });
+        const { callbacks } = config;
+        if (callbacks === undefined) {
+            config.callbacks = [stream];
+        }
+        else if (Array.isArray(callbacks)) {
+            config.callbacks = callbacks.concat([stream]);
+        }
+        else {
+            const copiedCallbacks = callbacks.copy();
+            copiedCallbacks.inheritableHandlers.push(stream);
+            config.callbacks = copiedCallbacks;
+        }
+        // The type is in camelCase but the API only accepts snake_case.
+        const camelCaseStreamOptions = {
+            include_names: streamOptions?.includeNames,
+            include_types: streamOptions?.includeTypes,
+            include_tags: streamOptions?.includeTags,
+            exclude_names: streamOptions?.excludeNames,
+            exclude_types: streamOptions?.excludeTypes,
+            exclude_tags: streamOptions?.excludeTags,
+        };
+        const response = await this.post("/stream_log", {
+            input,
+            config,
+            kwargs,
+            ...camelCaseStreamOptions,
+            diff: false,
+        });
+        const { body } = response;
+        if (!body) {
+            throw new Error("Could not begin remote stream log. Please check the given URL and try again.");
+        }
+        const runnableStream = (0, event_source_parse_1.convertEventStreamToIterableReadableDataStream)(body);
+        for await (const log of runnableStream) {
+            yield revive(JSON.parse(log));
+        }
+    }
 }
 exports.RemoteRunnable = RemoteRunnable;

package/dist/runnables/remote.d.ts

@@ -1,5 +1,6 @@
 import { Runnable, RunnableBatchOptions, RunnableConfig } from "@langchain/core/runnables";
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
+import { type LogStreamCallbackHandlerInput, type RunLogPatch } from "@langchain/core/tracers/log_stream";
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 type RemoteRunnableOptions = {
     timeout?: number;
@@ -23,5 +24,6 @@ export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends Run
     }): Promise<(RunOutput | Error)[]>;
     batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<RunOutput>>;
+    streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
 }
 export {};