langchain 0.0.195 → 0.0.197-rc.0

package/dist/schema/output_parser.js

@@ -1,301 +1 @@
-import { isBaseMessage, isBaseMessageChunk, ChatGenerationChunk, GenerationChunk, } from "./index.js";
-import { Runnable } from "./runnable/index.js";
-import { deepCompareStrict } from "../util/@cfworker/json-schema/index.js";
-/**
- * Abstract base class for parsing the output of a Large Language Model
- * (LLM) call. It provides methods for parsing the result of an LLM call
- * and invoking the parser with a given input.
- */
-export class BaseLLMOutputParser extends Runnable {
-    /**
-     * Parses the result of an LLM call with a given prompt. By default, it
-     * simply calls `parseResult`.
-     * @param generations The generations from an LLM call.
-     * @param _prompt The prompt used in the LLM call.
-     * @param callbacks Optional callbacks.
-     * @returns A promise of the parsed output.
-     */
-    parseResultWithPrompt(generations, _prompt, callbacks) {
-        return this.parseResult(generations, callbacks);
-    }
-    /**
-     * Calls the parser with a given input and optional configuration options.
-     * If the input is a string, it creates a generation with the input as
-     * text and calls `parseResult`. If the input is a `BaseMessage`, it
-     * creates a generation with the input as a message and the content of the
-     * input as text, and then calls `parseResult`.
-     * @param input The input to the parser, which can be a string or a `BaseMessage`.
-     * @param options Optional configuration options.
-     * @returns A promise of the parsed output.
-     */
-    async invoke(input, options) {
-        if (typeof input === "string") {
-            return this._callWithConfig(async (input) => this.parseResult([{ text: input }]), input, { ...options, runType: "parser" });
-        }
-        else {
-            return this._callWithConfig(async (input) => this.parseResult([
-                {
-                    message: input,
-                    text: typeof input.content === "string"
-                        ? input.content
-                        : JSON.stringify(input.content),
-                },
-            ]), input, { ...options, runType: "parser" });
-        }
-    }
-}
-/**
- * Class to parse the output of an LLM call.
- */
-export class BaseOutputParser extends BaseLLMOutputParser {
-    parseResult(generations, callbacks) {
-        return this.parse(generations[0].text, callbacks);
-    }
-    async parseWithPrompt(text, _prompt, callbacks) {
-        return this.parse(text, callbacks);
-    }
-    /**
-     * Return the string type key uniquely identifying this class of parser
-     */
-    _type() {
-        throw new Error("_type not implemented");
-    }
-}
-/**
- * Class to parse the output of an LLM call that also allows streaming inputs.
- */
-export class BaseTransformOutputParser extends BaseOutputParser {
-    async *_transform(inputGenerator) {
-        for await (const chunk of inputGenerator) {
-            if (typeof chunk === "string") {
-                yield this.parseResult([{ text: chunk }]);
-            }
-            else {
-                yield this.parseResult([
-                    {
-                        message: chunk,
-                        text: typeof chunk.content === "string"
-                            ? chunk.content
-                            : JSON.stringify(chunk.content),
-                    },
-                ]);
-            }
-        }
-    }
-    /**
-     * Transforms an asynchronous generator of input into an asynchronous
-     * generator of parsed output.
-     * @param inputGenerator An asynchronous generator of input.
-     * @param options A configuration object.
-     * @returns An asynchronous generator of parsed output.
-     */
-    async *transform(inputGenerator, options) {
-        yield* this._transformStreamWithConfig(inputGenerator, this._transform.bind(this), {
-            ...options,
-            runType: "parser",
-        });
-    }
-}
-/**
- * A base class for output parsers that can handle streaming input. It
- * extends the `BaseTransformOutputParser` class and provides a method for
- * converting parsed outputs into a diff format.
- */
-export class BaseCumulativeTransformOutputParser extends BaseTransformOutputParser {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "diff", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this.diff = fields?.diff ?? this.diff;
-    }
-    async *_transform(inputGenerator) {
-        let prevParsed;
-        let accGen;
-        for await (const chunk of inputGenerator) {
-            if (typeof chunk !== "string" && typeof chunk.content !== "string") {
-                throw new Error("Cannot handle non-string output.");
-            }
-            let chunkGen;
-            if (isBaseMessageChunk(chunk)) {
-                if (typeof chunk.content !== "string") {
-                    throw new Error("Cannot handle non-string message output.");
-                }
-                chunkGen = new ChatGenerationChunk({
-                    message: chunk,
-                    text: chunk.content,
-                });
-            }
-            else if (isBaseMessage(chunk)) {
-                if (typeof chunk.content !== "string") {
-                    throw new Error("Cannot handle non-string message output.");
-                }
-                chunkGen = new ChatGenerationChunk({
-                    message: chunk.toChunk(),
-                    text: chunk.content,
-                });
-            }
-            else {
-                chunkGen = new GenerationChunk({ text: chunk });
-            }
-            if (accGen === undefined) {
-                accGen = chunkGen;
-            }
-            else {
-                accGen = accGen.concat(chunkGen);
-            }
-            const parsed = await this.parsePartialResult([accGen]);
-            if (parsed !== undefined &&
-                parsed !== null &&
-                !deepCompareStrict(parsed, prevParsed)) {
-                if (this.diff) {
-                    yield this._diff(prevParsed, parsed);
-                }
-                else {
-                    yield parsed;
-                }
-                prevParsed = parsed;
-            }
-        }
-    }
-}
-/**
- * OutputParser that parses LLMResult into the top likely string.
- * @example
- * ```typescript
- * const promptTemplate = PromptTemplate.fromTemplate(
- *   "Tell me a joke about {topic}",
- * );
- *
- * const chain = RunnableSequence.from([
- *   promptTemplate,
- *   new ChatOpenAI({}),
- *   new StringOutputParser(),
- * ]);
- *
- * const result = await chain.invoke({ topic: "bears" });
- * console.log("What do you call a bear with no teeth? A gummy bear!");
- * ```
- */
-export class StringOutputParser extends BaseTransformOutputParser {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "output_parser"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-    }
-    static lc_name() {
-        return "StrOutputParser";
-    }
-    /**
-     * Parses a string output from an LLM call. This method is meant to be
-     * implemented by subclasses to define how a string output from an LLM
-     * should be parsed.
-     * @param text The string output from an LLM call.
-     * @param callbacks Optional callbacks.
-     * @returns A promise of the parsed output.
-     */
-    parse(text) {
-        return Promise.resolve(text);
-    }
-    getFormatInstructions() {
-        return "";
-    }
-}
-/**
- * OutputParser that parses LLMResult into the top likely string and
- * encodes it into bytes.
- */
-export class BytesOutputParser extends BaseTransformOutputParser {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "output_parser"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "textEncoder", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new TextEncoder()
-        });
-    }
-    static lc_name() {
-        return "BytesOutputParser";
-    }
-    parse(text) {
-        return Promise.resolve(this.textEncoder.encode(text));
-    }
-    getFormatInstructions() {
-        return "";
-    }
-}
-/**
- * Exception that output parsers should raise to signify a parsing error.
- *
- * This exists to differentiate parsing errors from other code or execution errors
- * that also may arise inside the output parser. OutputParserExceptions will be
- * available to catch and handle in ways to fix the parsing error, while other
- * errors will be raised.
- *
- * @param message - The error that's being re-raised or an error message.
- * @param llmOutput - String model output which is error-ing.
- * @param observation - String explanation of error which can be passed to a
- *     model to try and remediate the issue.
- * @param sendToLLM - Whether to send the observation and llm_output back to an Agent
- *     after an OutputParserException has been raised. This gives the underlying
- *     model driving the agent the context that the previous output was improperly
- *     structured, in the hopes that it will update the output to the correct
- *     format.
- */
-export class OutputParserException extends Error {
-    constructor(message, llmOutput, observation, sendToLLM = false) {
-        super(message);
-        Object.defineProperty(this, "llmOutput", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "observation", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "sendToLLM", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.llmOutput = llmOutput;
-        this.observation = observation;
-        this.sendToLLM = sendToLLM;
-        if (sendToLLM) {
-            if (observation === undefined || llmOutput === undefined) {
-                throw new Error("Arguments 'observation' & 'llmOutput' are required if 'sendToLlm' is true");
-            }
-        }
-    }
-}
+export * from "langchain-core/output_parsers";

package/dist/schema/retriever.cjs

@@ -1,79 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseRetriever = void 0;
-const manager_js_1 = require("../callbacks/manager.cjs");
-const index_js_1 = require("./runnable/index.cjs");
-/**
- * Abstract base class for a Document retrieval system. A retrieval system
- * is defined as something that can take string queries and return the
- * most 'relevant' Documents from some source.
- */
-class BaseRetriever extends index_js_1.Runnable {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "callbacks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "tags", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "metadata", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "verbose", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.callbacks = fields?.callbacks;
-        this.tags = fields?.tags ?? [];
-        this.metadata = fields?.metadata ?? {};
-        this.verbose = fields?.verbose ?? false;
-    }
-    /**
-     * TODO: This should be an abstract method, but we'd like to avoid breaking
-     * changes to people currently using subclassed custom retrievers.
-     * Change it on next major release.
-     */
-    _getRelevantDocuments(_query, _callbacks) {
-        throw new Error("Not implemented!");
-    }
-    async invoke(input, options) {
-        return this.getRelevantDocuments(input, options);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    /**
-     * Main method used to retrieve relevant documents. It takes a query
-     * string and an optional configuration object, and returns a promise that
-     * resolves to an array of `Document` objects. This method handles the
-     * retrieval process, including starting and ending callbacks, and error
-     * handling.
-     * @param query The query string to retrieve relevant documents for.
-     * @param config Optional configuration object for the retrieval process.
-     * @returns A promise that resolves to an array of `Document` objects.
-     */
-    async getRelevantDocuments(query, config) {
-        const parsedConfig = (0, manager_js_1.parseCallbackConfigArg)(config);
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
-        try {
-            const results = await this._getRelevantDocuments(query, runManager);
-            await runManager?.handleRetrieverEnd(results);
-            return results;
-        }
-        catch (error) {
-            await runManager?.handleRetrieverError(error);
-            throw error;
-        }
-    }
-}
-exports.BaseRetriever = BaseRetriever;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("langchain-core/retrievers"), exports);

package/dist/schema/retriever.d.ts

@@ -1,43 +1 @@
-import { BaseCallbackConfig, CallbackManagerForRetrieverRun, Callbacks } from "../callbacks/manager.js";
-import { Document } from "../document.js";
-import { Runnable } from "./runnable/index.js";
-import { RunnableConfig } from "./runnable/config.js";
-/**
- * Base Retriever class. All indexes should extend this class.
- */
-export interface BaseRetrieverInput {
-    callbacks?: Callbacks;
-    tags?: string[];
-    metadata?: Record<string, unknown>;
-    verbose?: boolean;
-}
-/**
- * Abstract base class for a Document retrieval system. A retrieval system
- * is defined as something that can take string queries and return the
- * most 'relevant' Documents from some source.
- */
-export declare abstract class BaseRetriever extends Runnable<string, Document[]> {
-    callbacks?: Callbacks;
-    tags?: string[];
-    metadata?: Record<string, unknown>;
-    verbose?: boolean;
-    constructor(fields?: BaseRetrieverInput);
-    /**
-     * TODO: This should be an abstract method, but we'd like to avoid breaking
-     * changes to people currently using subclassed custom retrievers.
-     * Change it on next major release.
-     */
-    _getRelevantDocuments(_query: string, _callbacks?: CallbackManagerForRetrieverRun): Promise<Document[]>;
-    invoke(input: string, options?: RunnableConfig): Promise<Document[]>;
-    /**
-     * Main method used to retrieve relevant documents. It takes a query
-     * string and an optional configuration object, and returns a promise that
-     * resolves to an array of `Document` objects. This method handles the
-     * retrieval process, including starting and ending callbacks, and error
-     * handling.
-     * @param query The query string to retrieve relevant documents for.
-     * @param config Optional configuration object for the retrieval process.
-     * @returns A promise that resolves to an array of `Document` objects.
-     */
-    getRelevantDocuments(query: string, config?: Callbacks | BaseCallbackConfig): Promise<Document[]>;
-}
+export * from "langchain-core/retrievers";

package/dist/schema/retriever.js

@@ -1,75 +1 @@
-import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.js";
-import { Runnable } from "./runnable/index.js";
-/**
- * Abstract base class for a Document retrieval system. A retrieval system
- * is defined as something that can take string queries and return the
- * most 'relevant' Documents from some source.
- */
-export class BaseRetriever extends Runnable {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "callbacks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "tags", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "metadata", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "verbose", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.callbacks = fields?.callbacks;
-        this.tags = fields?.tags ?? [];
-        this.metadata = fields?.metadata ?? {};
-        this.verbose = fields?.verbose ?? false;
-    }
-    /**
-     * TODO: This should be an abstract method, but we'd like to avoid breaking
-     * changes to people currently using subclassed custom retrievers.
-     * Change it on next major release.
-     */
-    _getRelevantDocuments(_query, _callbacks) {
-        throw new Error("Not implemented!");
-    }
-    async invoke(input, options) {
-        return this.getRelevantDocuments(input, options);
-    }
-    /**
-     * Main method used to retrieve relevant documents. It takes a query
-     * string and an optional configuration object, and returns a promise that
-     * resolves to an array of `Document` objects. This method handles the
-     * retrieval process, including starting and ending callbacks, and error
-     * handling.
-     * @param query The query string to retrieve relevant documents for.
-     * @param config Optional configuration object for the retrieval process.
-     * @returns A promise that resolves to an array of `Document` objects.
-     */
-    async getRelevantDocuments(query, config) {
-        const parsedConfig = parseCallbackConfigArg(config);
-        const callbackManager_ = await CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
-        try {
-            const results = await this._getRelevantDocuments(query, runManager);
-            await runManager?.handleRetrieverEnd(results);
-            return results;
-        }
-        catch (error) {
-            await runManager?.handleRetrieverError(error);
-            throw error;
-        }
-    }
-}
+export * from "langchain-core/retrievers";