langchain 0.0.195 → 0.0.197-rc.0

package/dist/schema/output_parser.cjs

@@ -1,311 +1,17 @@
 "use strict";
+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]; } };
+    }
+    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 });
-exports.OutputParserException = exports.BytesOutputParser = exports.StringOutputParser = exports.BaseCumulativeTransformOutputParser = exports.BaseTransformOutputParser = exports.BaseOutputParser = exports.BaseLLMOutputParser = void 0;
-const index_js_1 = require("./index.cjs");
-const index_js_2 = require("./runnable/index.cjs");
-const index_js_3 = require("../util/@cfworker/json-schema/index.cjs");
-/**
- * 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.
- */
-class BaseLLMOutputParser extends index_js_2.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" });
-        }
-    }
-}
-exports.BaseLLMOutputParser = BaseLLMOutputParser;
-/**
- * Class to parse the output of an LLM call.
- */
-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");
-    }
-}
-exports.BaseOutputParser = BaseOutputParser;
-/**
- * Class to parse the output of an LLM call that also allows streaming inputs.
- */
-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",
-        });
-    }
-}
-exports.BaseTransformOutputParser = BaseTransformOutputParser;
-/**
- * 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.
- */
-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 ((0, index_js_1.isBaseMessageChunk)(chunk)) {
-                if (typeof chunk.content !== "string") {
-                    throw new Error("Cannot handle non-string message output.");
-                }
-                chunkGen = new index_js_1.ChatGenerationChunk({
-                    message: chunk,
-                    text: chunk.content,
-                });
-            }
-            else if ((0, index_js_1.isBaseMessage)(chunk)) {
-                if (typeof chunk.content !== "string") {
-                    throw new Error("Cannot handle non-string message output.");
-                }
-                chunkGen = new index_js_1.ChatGenerationChunk({
-                    message: chunk.toChunk(),
-                    text: chunk.content,
-                });
-            }
-            else {
-                chunkGen = new index_js_1.GenerationChunk({ text: chunk });
-            }
-            if (accGen === undefined) {
-                accGen = chunkGen;
-            }
-            else {
-                accGen = accGen.concat(chunkGen);
-            }
-            const parsed = await this.parsePartialResult([accGen]);
-            if (parsed !== undefined &&
-                parsed !== null &&
-                !(0, index_js_3.deepCompareStrict)(parsed, prevParsed)) {
-                if (this.diff) {
-                    yield this._diff(prevParsed, parsed);
-                }
-                else {
-                    yield parsed;
-                }
-                prevParsed = parsed;
-            }
-        }
-    }
-}
-exports.BaseCumulativeTransformOutputParser = BaseCumulativeTransformOutputParser;
-/**
- * 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!");
- * ```
- */
-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 "";
-    }
-}
-exports.StringOutputParser = StringOutputParser;
-/**
- * OutputParser that parses LLMResult into the top likely string and
- * encodes it into bytes.
- */
-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 "";
-    }
-}
-exports.BytesOutputParser = BytesOutputParser;
-/**
- * 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.
- */
-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");
-            }
-        }
-    }
-}
-exports.OutputParserException = OutputParserException;
+__exportStar(require("langchain-core/output_parsers"), exports);

package/dist/schema/output_parser.d.ts

@@ -1,173 +1 @@
-import { BaseCallbackConfig, Callbacks } from "../callbacks/manager.js";
-import { BasePromptValue, Generation, ChatGeneration, BaseMessage } from "./index.js";
-import { Runnable } from "./runnable/index.js";
-import { RunnableConfig } from "./runnable/config.js";
-/**
- * Options for formatting instructions.
- */
-export interface FormatInstructionsOptions {
-}
-/**
- * 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 declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {
-    /**
-     * Parses the result of an LLM call. This method is meant to be
-     * implemented by subclasses to define how the output from the LLM should
-     * be parsed.
-     * @param generations The generations from an LLM call.
-     * @param callbacks Optional callbacks.
-     * @returns A promise of the parsed output.
-     */
-    abstract parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
-    /**
-     * 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: Generation[] | ChatGeneration[], _prompt: BasePromptValue, callbacks?: Callbacks): Promise<T>;
-    /**
-     * 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.
-     */
-    invoke(input: string | BaseMessage, options?: RunnableConfig): Promise<T>;
-}
-/**
- * Class to parse the output of an LLM call.
- */
-export declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {
-    parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
-    /**
-     * Parse the output of an LLM call.
-     *
-     * @param text - LLM output to parse.
-     * @returns Parsed output.
-     */
-    abstract parse(text: string, callbacks?: Callbacks): Promise<T>;
-    parseWithPrompt(text: string, _prompt: BasePromptValue, callbacks?: Callbacks): Promise<T>;
-    /**
-     * Return a string describing the format of the output.
-     * @returns Format instructions.
-     * @param options - Options for formatting instructions.
-     * @example
-     * ```json
-     * {
-     *  "foo": "bar"
-     * }
-     * ```
-     */
-    abstract getFormatInstructions(options?: FormatInstructionsOptions): string;
-    /**
-     * Return the string type key uniquely identifying this class of parser
-     */
-    _type(): string;
-}
-/**
- * Class to parse the output of an LLM call that also allows streaming inputs.
- */
-export declare abstract class BaseTransformOutputParser<T = unknown> extends BaseOutputParser<T> {
-    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;
-    /**
-     * 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.
-     */
-    transform(inputGenerator: AsyncGenerator<string | BaseMessage>, options: BaseCallbackConfig): AsyncGenerator<T>;
-}
-export type BaseCumulativeTransformOutputParserInput = {
-    diff?: boolean;
-};
-/**
- * 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 declare abstract class BaseCumulativeTransformOutputParser<T = unknown> extends BaseTransformOutputParser<T> {
-    protected diff: boolean;
-    constructor(fields?: BaseCumulativeTransformOutputParserInput);
-    protected abstract _diff(prev: any | undefined, next: any): any;
-    abstract parsePartialResult(generations: Generation[] | ChatGeneration[]): Promise<T | undefined>;
-    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<T>;
-}
-/**
- * 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 declare class StringOutputParser extends BaseTransformOutputParser<string> {
-    static lc_name(): string;
-    lc_namespace: string[];
-    lc_serializable: boolean;
-    /**
-     * 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: string): Promise<string>;
-    getFormatInstructions(): string;
-}
-/**
- * OutputParser that parses LLMResult into the top likely string and
- * encodes it into bytes.
- */
-export declare class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {
-    static lc_name(): string;
-    lc_namespace: string[];
-    lc_serializable: boolean;
-    protected textEncoder: TextEncoder;
-    parse(text: string): Promise<Uint8Array>;
-    getFormatInstructions(): string;
-}
-/**
- * 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 declare class OutputParserException extends Error {
-    llmOutput?: string;
-    observation?: string;
-    sendToLLM: boolean;
-    constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);
-}
+export * from "langchain-core/output_parsers";