langchain 0.0.143 → 0.0.144

package/callbacks/handlers/llmonitor.cjs

@@ -0,0 +1 @@
+module.exports = require('../../dist/callbacks/handlers/llmonitor.cjs');

package/callbacks/handlers/llmonitor.d.ts

@@ -0,0 +1 @@
+export * from '../../dist/callbacks/handlers/llmonitor.js'

package/callbacks/handlers/llmonitor.js

@@ -0,0 +1 @@
+export * from '../../dist/callbacks/handlers/llmonitor.js'

package/dist/agents/mrkl/outputParser.cjs

@@ -41,7 +41,7 @@ class ZeroShotAgentOutputParser extends types_js_1.AgentActionOutputParser {
                 log: text,
             };
         }
-        const match = /Action: ([\s\S]*?)(?:\nAction Input: ([\s\S]*?))?$/.exec(text);
+        const match = /Action:([\s\S]*?)(?:\nAction Input:([\s\S]*?))?$/.exec(text);
         if (!match) {
             throw new output_parser_js_1.OutputParserException(`Could not parse LLM output: ${text}`);
         }

package/dist/agents/mrkl/outputParser.js

@@ -38,7 +38,7 @@ export class ZeroShotAgentOutputParser extends AgentActionOutputParser {
                 log: text,
             };
         }
-        const match = /Action: ([\s\S]*?)(?:\nAction Input: ([\s\S]*?))?$/.exec(text);
+        const match = /Action:([\s\S]*?)(?:\nAction Input:([\s\S]*?))?$/.exec(text);
         if (!match) {
             throw new OutputParserException(`Could not parse LLM output: ${text}`);
         }

package/dist/base_language/index.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateMaxTokens = exports.BaseLanguageModel = exports.BaseLangChain = void 0;
+const index_js_1 = require("../schema/index.cjs");
 const async_caller_js_1 = require("../util/async_caller.cjs");
 const count_tokens_js_1 = require("./count_tokens.cjs");
 const tiktoken_js_1 = require("../util/tiktoken.cjs");
@@ -110,7 +111,7 @@ class BaseLanguageModel extends BaseLangChain {
             return new base_js_1.StringPromptValue(input);
         }
         else if (Array.isArray(input)) {
-            return new chat_js_1.ChatPromptValue(input);
+            return new chat_js_1.ChatPromptValue(input.map(index_js_1.coerceMessageLikeToMessage));
         }
         else {
             return input;

package/dist/base_language/index.d.ts

@@ -1,4 +1,5 @@
-import { BaseMessage, BasePromptValue, LLMResult } from "../schema/index.js";
+import type { OpenAI as OpenAIClient } from "openai";
+import { BaseMessage, BaseMessageLike, BasePromptValue, LLMResult } from "../schema/index.js";
 import { BaseCallbackConfig, CallbackManager, Callbacks } from "../callbacks/manager.js";
 import { AsyncCaller, AsyncCallerParams } from "../util/async_caller.js";
 import { Runnable, RunnableConfig } from "../schema/runnable.js";
@@ -56,7 +57,11 @@ export interface BaseLanguageModelCallOptions extends BaseCallbackConfig {
      */
     signal?: AbortSignal;
 }
-export type BaseLanguageModelInput = BasePromptValue | string | BaseMessage[];
+export interface BaseFunctionCallOptions extends BaseLanguageModelCallOptions {
+    function_call?: OpenAIClient.Chat.ChatCompletionCreateParams.FunctionCallOption;
+    functions?: OpenAIClient.Chat.ChatCompletionCreateParams.Function[];
+}
+export type BaseLanguageModelInput = BasePromptValue | string | BaseMessageLike[];
 /**
  * Base class for language models.
  */

package/dist/base_language/index.js

@@ -1,3 +1,4 @@
+import { coerceMessageLikeToMessage, } from "../schema/index.js";
 import { AsyncCaller } from "../util/async_caller.js";
 import { getModelNameForTiktoken } from "./count_tokens.js";
 import { encodingForModel } from "../util/tiktoken.js";
@@ -106,7 +107,7 @@ export class BaseLanguageModel extends BaseLangChain {
             return new StringPromptValue(input);
         }
         else if (Array.isArray(input)) {
-            return new ChatPromptValue(input);
+            return new ChatPromptValue(input.map(coerceMessageLikeToMessage));
         }
         else {
             return input;

package/dist/callbacks/handlers/llmonitor.cjs

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMonitorHandler = exports.convertToLLMonitorMessages = void 0;
+const llmonitor_1 = __importDefault(require("llmonitor"));
+const env_js_1 = require("../../util/env.cjs");
+const base_js_1 = require("../base.cjs");
+// Langchain Helpers
+// Input can be either a single message, an array of message, or an array of array of messages (batch requests)
+const parseRole = (id) => {
+    const roleHint = id[id.length - 1];
+    if (roleHint.includes("Human"))
+        return "user";
+    if (roleHint.includes("System"))
+        return "system";
+    if (roleHint.includes("AI"))
+        return "ai";
+    if (roleHint.includes("Function"))
+        return "function";
+    return "ai";
+};
+const convertToLLMonitorMessages = (input) => {
+    const parseMessage = (raw) => {
+        if (typeof raw === "string")
+            return raw;
+        // sometimes the message is nested in a "message" property
+        if ("message" in raw)
+            return parseMessage(raw.message);
+        // Serialize
+        const message = JSON.parse(JSON.stringify(raw));
+        try {
+            // "id" contains an array describing the constructor, with last item actual schema type
+            const role = parseRole(message.id);
+            const obj = message.kwargs;
+            const text = message.text ?? obj.content;
+            const functionCall = obj.additional_kwargs?.function_call;
+            return {
+                role,
+                text,
+                functionCall,
+            };
+        }
+        catch (e) {
+            // if parsing fails, return the original message
+            return message.text ?? message;
+        }
+    };
+    if (Array.isArray(input)) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore Confuses the compiler
+        return input.length === 1
+            ? (0, exports.convertToLLMonitorMessages)(input[0])
+            : input.map(exports.convertToLLMonitorMessages);
+    }
+    return parseMessage(input);
+};
+exports.convertToLLMonitorMessages = convertToLLMonitorMessages;
+const parseInput = (rawInput) => {
+    if (!rawInput)
+        return null;
+    const { input, inputs, question } = rawInput;
+    if (input)
+        return input;
+    if (inputs)
+        return inputs;
+    if (question)
+        return question;
+    return rawInput;
+};
+const parseOutput = (rawOutput) => {
+    if (!rawOutput)
+        return null;
+    const { text, output, answer } = rawOutput;
+    if (text)
+        return text;
+    if (answer)
+        return answer;
+    if (output)
+        return output;
+    return rawOutput;
+};
+class LLMonitorHandler extends base_js_1.BaseCallbackHandler {
+    constructor(fields = {}) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "llmonitor_handler"
+        });
+        Object.defineProperty(this, "monitor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.monitor = llmonitor_1.default;
+        if (fields) {
+            const { appId, apiUrl, verbose } = fields;
+            this.monitor.init({
+                verbose,
+                appId: appId ?? (0, env_js_1.getEnvironmentVariable)("LLMONITOR_APP_ID"),
+                apiUrl: apiUrl ?? (0, env_js_1.getEnvironmentVariable)("LLMONITOR_API_URL"),
+            });
+        }
+    }
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
+        const params = {
+            ...(extraParams?.invocation_params || {}),
+            ...(metadata || {}),
+        };
+        const name = params?.model || params?.name || params?.model_name || llm.id.at(-1);
+        const userId = params?.userId || undefined;
+        const userProps = params?.userProps || undefined;
+        await this.monitor.trackEvent("llm", "start", {
+            runId,
+            parentRunId,
+            name,
+            input: (0, exports.convertToLLMonitorMessages)(prompts),
+            extra: params,
+            userId,
+            userProps,
+            tags,
+            runtime: "langchain-js",
+        });
+    }
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata) {
+        const params = {
+            ...(extraParams?.invocation_params || {}),
+            ...(metadata || {}),
+        };
+        const name = params?.model || params?.name || params?.model_name || llm.id.at(-1);
+        const userId = params?.userId || undefined;
+        const userProps = params?.userProps || undefined;
+        await this.monitor.trackEvent("llm", "start", {
+            runId,
+            parentRunId,
+            name,
+            input: (0, exports.convertToLLMonitorMessages)(messages),
+            extra: params,
+            userId,
+            userProps,
+            tags,
+            runtime: "langchain-js",
+        });
+    }
+    async handleLLMEnd(output, runId) {
+        const { generations, llmOutput } = output;
+        await this.monitor.trackEvent("llm", "end", {
+            runId,
+            output: (0, exports.convertToLLMonitorMessages)(generations),
+            tokensUsage: {
+                completion: llmOutput?.tokenUsage?.completionTokens,
+                prompt: llmOutput?.tokenUsage?.promptTokens,
+            },
+        });
+    }
+    async handleLLMError(error, runId) {
+        await this.monitor.trackEvent("llm", "error", {
+            runId,
+            error,
+        });
+    }
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata) {
+        // allow the user to specify an agent name
+        const chainName = chain.id.at(-1);
+        const name = (metadata?.agentName ?? chainName);
+        // Attempt to automatically detect if this is an agent or chain
+        const runType = metadata?.agentName ||
+            ["AgentExecutor", "PlanAndExecute"].includes(chainName)
+            ? "agent"
+            : "chain";
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { agentName, ...rest } = metadata || {};
+        await this.monitor.trackEvent(runType, "start", {
+            runId,
+            parentRunId,
+            name,
+            input: parseInput(inputs),
+            extra: rest,
+            tags,
+            runtime: "langchain-js",
+        });
+    }
+    async handleChainEnd(outputs, runId) {
+        await this.monitor.trackEvent("chain", "end", {
+            runId,
+            output: parseOutput(outputs),
+        });
+    }
+    async handleChainError(error, runId) {
+        await this.monitor.trackEvent("chain", "error", {
+            runId,
+            error,
+        });
+    }
+    async handleToolStart(tool, input, runId, parentRunId, tags, metadata) {
+        await this.monitor.trackEvent("tool", "start", {
+            runId,
+            parentRunId,
+            name: tool.id[tool.id.length - 1],
+            input,
+            extra: metadata,
+            tags,
+            runtime: "langchain-js",
+        });
+    }
+    async handleToolEnd(output, runId) {
+        await this.monitor.trackEvent("tool", "end", {
+            runId,
+            output,
+        });
+    }
+    async handleToolError(error, runId) {
+        await this.monitor.trackEvent("tool", "error", {
+            runId,
+            error,
+        });
+    }
+}
+exports.LLMonitorHandler = LLMonitorHandler;

package/dist/callbacks/handlers/llmonitor.d.ts

@@ -0,0 +1,35 @@
+import monitor from "llmonitor";
+import { LLMonitorOptions, ChatMessage } from "llmonitor/types";
+import { BaseRun, RunUpdate as BaseRunUpdate, KVMap } from "langsmith/schemas";
+import { BaseMessage, ChainValues, Generation, LLMResult } from "../../schema/index.js";
+import { Serialized } from "../../load/serializable.js";
+import { BaseCallbackHandler, BaseCallbackHandlerInput } from "../base.js";
+type Message = BaseMessage | Generation | string;
+type OutputMessage = ChatMessage | string;
+export declare const convertToLLMonitorMessages: (input: Message | Message[] | Message[][]) => OutputMessage | OutputMessage[] | OutputMessage[][];
+export interface Run extends BaseRun {
+    id: string;
+    child_runs: this[];
+    child_execution_order: number;
+}
+export interface RunUpdate extends BaseRunUpdate {
+    events: BaseRun["events"];
+}
+export interface LLMonitorHandlerFields extends BaseCallbackHandlerInput, LLMonitorOptions {
+}
+export declare class LLMonitorHandler extends BaseCallbackHandler implements LLMonitorHandlerFields {
+    name: string;
+    monitor: typeof monitor;
+    constructor(fields?: LLMonitorHandlerFields);
+    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap): Promise<void>;
+    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap): Promise<void>;
+    handleLLMEnd(output: LLMResult, runId: string): Promise<void>;
+    handleLLMError(error: Error, runId: string): Promise<void>;
+    handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap): Promise<void>;
+    handleChainEnd(outputs: ChainValues, runId: string): Promise<void>;
+    handleChainError(error: Error, runId: string): Promise<void>;
+    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap): Promise<void>;
+    handleToolEnd(output: string, runId: string): Promise<void>;
+    handleToolError(error: Error, runId: string): Promise<void>;
+}
+export {};

package/dist/callbacks/handlers/llmonitor.js

@@ -0,0 +1,215 @@
+import monitor from "llmonitor";
+import { getEnvironmentVariable } from "../../util/env.js";
+import { BaseCallbackHandler } from "../base.js";
+// Langchain Helpers
+// Input can be either a single message, an array of message, or an array of array of messages (batch requests)
+const parseRole = (id) => {
+    const roleHint = id[id.length - 1];
+    if (roleHint.includes("Human"))
+        return "user";
+    if (roleHint.includes("System"))
+        return "system";
+    if (roleHint.includes("AI"))
+        return "ai";
+    if (roleHint.includes("Function"))
+        return "function";
+    return "ai";
+};
+export const convertToLLMonitorMessages = (input) => {
+    const parseMessage = (raw) => {
+        if (typeof raw === "string")
+            return raw;
+        // sometimes the message is nested in a "message" property
+        if ("message" in raw)
+            return parseMessage(raw.message);
+        // Serialize
+        const message = JSON.parse(JSON.stringify(raw));
+        try {
+            // "id" contains an array describing the constructor, with last item actual schema type
+            const role = parseRole(message.id);
+            const obj = message.kwargs;
+            const text = message.text ?? obj.content;
+            const functionCall = obj.additional_kwargs?.function_call;
+            return {
+                role,
+                text,
+                functionCall,
+            };
+        }
+        catch (e) {
+            // if parsing fails, return the original message
+            return message.text ?? message;
+        }
+    };
+    if (Array.isArray(input)) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore Confuses the compiler
+        return input.length === 1
+            ? convertToLLMonitorMessages(input[0])
+            : input.map(convertToLLMonitorMessages);
+    }
+    return parseMessage(input);
+};
+const parseInput = (rawInput) => {
+    if (!rawInput)
+        return null;
+    const { input, inputs, question } = rawInput;
+    if (input)
+        return input;
+    if (inputs)
+        return inputs;
+    if (question)
+        return question;
+    return rawInput;
+};
+const parseOutput = (rawOutput) => {
+    if (!rawOutput)
+        return null;
+    const { text, output, answer } = rawOutput;
+    if (text)
+        return text;
+    if (answer)
+        return answer;
+    if (output)
+        return output;
+    return rawOutput;
+};
+export class LLMonitorHandler extends BaseCallbackHandler {
+    constructor(fields = {}) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "llmonitor_handler"
+        });
+        Object.defineProperty(this, "monitor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.monitor = monitor;
+        if (fields) {
+            const { appId, apiUrl, verbose } = fields;
+            this.monitor.init({
+                verbose,
+                appId: appId ?? getEnvironmentVariable("LLMONITOR_APP_ID"),
+                apiUrl: apiUrl ?? getEnvironmentVariable("LLMONITOR_API_URL"),
+            });
+        }
+    }
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
+        const params = {
+            ...(extraParams?.invocation_params || {}),
+            ...(metadata || {}),
+        };
+        const name = params?.model || params?.name || params?.model_name || llm.id.at(-1);
+        const userId = params?.userId || undefined;
+        const userProps = params?.userProps || undefined;
+        await this.monitor.trackEvent("llm", "start", {
+            runId,
+            parentRunId,
+            name,
+            input: convertToLLMonitorMessages(prompts),
+            extra: params,
+            userId,
+            userProps,
+            tags,
+            runtime: "langchain-js",
+        });
+    }
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata) {
+        const params = {
+            ...(extraParams?.invocation_params || {}),
+            ...(metadata || {}),
+        };
+        const name = params?.model || params?.name || params?.model_name || llm.id.at(-1);
+        const userId = params?.userId || undefined;
+        const userProps = params?.userProps || undefined;
+        await this.monitor.trackEvent("llm", "start", {
+            runId,
+            parentRunId,
+            name,
+            input: convertToLLMonitorMessages(messages),
+            extra: params,
+            userId,
+            userProps,
+            tags,
+            runtime: "langchain-js",
+        });
+    }
+    async handleLLMEnd(output, runId) {
+        const { generations, llmOutput } = output;
+        await this.monitor.trackEvent("llm", "end", {
+            runId,
+            output: convertToLLMonitorMessages(generations),
+            tokensUsage: {
+                completion: llmOutput?.tokenUsage?.completionTokens,
+                prompt: llmOutput?.tokenUsage?.promptTokens,
+            },
+        });
+    }
+    async handleLLMError(error, runId) {
+        await this.monitor.trackEvent("llm", "error", {
+            runId,
+            error,
+        });
+    }
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata) {
+        // allow the user to specify an agent name
+        const chainName = chain.id.at(-1);
+        const name = (metadata?.agentName ?? chainName);
+        // Attempt to automatically detect if this is an agent or chain
+        const runType = metadata?.agentName ||
+            ["AgentExecutor", "PlanAndExecute"].includes(chainName)
+            ? "agent"
+            : "chain";
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { agentName, ...rest } = metadata || {};
+        await this.monitor.trackEvent(runType, "start", {
+            runId,
+            parentRunId,
+            name,
+            input: parseInput(inputs),
+            extra: rest,
+            tags,
+            runtime: "langchain-js",
+        });
+    }
+    async handleChainEnd(outputs, runId) {
+        await this.monitor.trackEvent("chain", "end", {
+            runId,
+            output: parseOutput(outputs),
+        });
+    }
+    async handleChainError(error, runId) {
+        await this.monitor.trackEvent("chain", "error", {
+            runId,
+            error,
+        });
+    }
+    async handleToolStart(tool, input, runId, parentRunId, tags, metadata) {
+        await this.monitor.trackEvent("tool", "start", {
+            runId,
+            parentRunId,
+            name: tool.id[tool.id.length - 1],
+            input,
+            extra: metadata,
+            tags,
+            runtime: "langchain-js",
+        });
+    }
+    async handleToolEnd(output, runId) {
+        await this.monitor.trackEvent("tool", "end", {
+            runId,
+            output,
+        });
+    }
+    async handleToolError(error, runId) {
+        await this.monitor.trackEvent("tool", "error", {
+            runId,
+            error,
+        });
+    }
+}

package/dist/chains/openai_functions/extraction.d.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { ChatOpenAI } from "../../chat_models/openai.js";
 import { FunctionParameters } from "../../output_parsers/openai_functions.js";
 import { LLMChain } from "../llm_chain.js";
-import { AnthropicFunctions } from "../../experimental/chat_models/anthropic_functions.js";
+import { BaseChatModel } from "../../chat_models/index.js";
+import { BaseFunctionCallOptions } from "../../base_language/index.js";
 /**
  * Function that creates an extraction chain using the provided JSON schema.
  * It sets up the necessary components, such as the prompt, output parser, and tags.
@@ -10,7 +10,7 @@ import { AnthropicFunctions } from "../../experimental/chat_models/anthropic_fun
  * @param llm Must be a ChatOpenAI or AnthropicFunctions model that supports function calling.
  * @returns A LLMChain instance configured to return data matching the schema.
  */
-export declare function createExtractionChain(schema: FunctionParameters, llm: ChatOpenAI | AnthropicFunctions): LLMChain<object, ChatOpenAI | AnthropicFunctions>;
+export declare function createExtractionChain(schema: FunctionParameters, llm: BaseChatModel<BaseFunctionCallOptions>): LLMChain<object, BaseChatModel<BaseFunctionCallOptions>>;
 /**
  * Function that creates an extraction chain from a Zod schema. It
  * converts the Zod schema to a JSON schema using zod-to-json-schema
@@ -19,4 +19,4 @@ export declare function createExtractionChain(schema: FunctionParameters, llm: C
  * @param llm Must be a ChatOpenAI or AnthropicFunctions model that supports function calling.
  * @returns A LLMChain instance configured to return data matching the schema.
  */
-export declare function createExtractionChainFromZod(schema: z.ZodObject<any, any, any, any>, llm: ChatOpenAI | AnthropicFunctions): LLMChain<object, ChatOpenAI | AnthropicFunctions>;
+export declare function createExtractionChainFromZod(schema: z.ZodObject<any, any, any, any>, llm: BaseChatModel<BaseFunctionCallOptions>): LLMChain<object, BaseChatModel<BaseFunctionCallOptions>>;

package/dist/chains/openai_functions/openapi.d.ts

@@ -1,15 +1,15 @@
 import type { OpenAPIV3_1 } from "openapi-types";
 import { BaseChain } from "../base.js";
 import { LLMChainInput } from "../llm_chain.js";
-import { ChatOpenAI } from "../../chat_models/openai.js";
 import { BasePromptTemplate } from "../../prompts/base.js";
 import { SequentialChain } from "../sequential_chain.js";
-import { AnthropicFunctions } from "../../experimental/chat_models/anthropic_functions.js";
+import { BaseChatModel } from "../../chat_models/index.js";
+import { BaseFunctionCallOptions } from "../../base_language/index.js";
 /**
  * Type representing the options for creating an OpenAPI chain.
  */
 export type OpenAPIChainOptions = {
-    llm?: ChatOpenAI | AnthropicFunctions;
+    llm?: BaseChatModel<BaseFunctionCallOptions>;
     prompt?: BasePromptTemplate;
     requestChain?: BaseChain;
     llmChainInputs?: LLMChainInput;

package/dist/chains/openai_functions/structured_output.d.ts

@@ -7,7 +7,8 @@ import { BasePromptTemplate } from "../../prompts/index.js";
 import { BaseLLMOutputParser } from "../../schema/output_parser.js";
 import { OutputFunctionsParser } from "../../output_parsers/openai_functions.js";
 import { ChatGeneration } from "../../schema/index.js";
-import { AnthropicFunctions } from "../../experimental/chat_models/anthropic_functions.js";
+import { BaseChatModel } from "../../chat_models/index.js";
+import { BaseFunctionCallOptions } from "../../base_language/index.js";
 /**
  * Type representing the input for creating a structured output chain. It
  * extends the LLMChainInput type and includes an additional
@@ -17,7 +18,7 @@ import { AnthropicFunctions } from "../../experimental/chat_models/anthropic_fun
 export type StructuredOutputChainInput = Omit<LLMChainInput, "outputParser" | "llm"> & {
     outputSchema: JsonSchema7Type;
     prompt: BasePromptTemplate;
-    llm?: ChatOpenAI | AnthropicFunctions;
+    llm?: BaseChatModel<BaseFunctionCallOptions>;
 };
 /**
  * Class that extends the BaseLLMOutputParser class. It provides
@@ -45,5 +46,5 @@ export declare class FunctionCallStructuredOutputParser<T extends z.AnyZodObject
  * as well as an additional required "outputSchema" JSON Schema object.
  * @returns OpenAPIChain
  */
-export declare function createStructuredOutputChain<T extends z.AnyZodObject = z.AnyZodObject>(input: StructuredOutputChainInput): LLMChain<any, ChatOpenAI | AnthropicFunctions>;
-export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput, "outputSchema">): LLMChain<any, ChatOpenAI | AnthropicFunctions>;
+export declare function createStructuredOutputChain<T extends z.AnyZodObject = z.AnyZodObject>(input: StructuredOutputChainInput): LLMChain<any, ChatOpenAI | BaseChatModel<BaseFunctionCallOptions>>;
+export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput, "outputSchema">): LLMChain<any, ChatOpenAI | BaseChatModel<BaseFunctionCallOptions>>;

package/dist/chains/openai_functions/tagging.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { ChatOpenAI } from "../../chat_models/openai.js";
 import { PromptTemplate } from "../../prompts/prompt.js";
 import { FunctionParameters } from "../../output_parsers/openai_functions.js";
 import { LLMChain, LLMChainInput } from "../llm_chain.js";
-import { AnthropicFunctions } from "../../experimental/chat_models/anthropic_functions.js";
+import { BaseChatModel } from "../../chat_models/index.js";
+import { BaseFunctionCallOptions } from "../../base_language/index.js";
 /**
  * Type representing the options for creating a tagging chain.
  */
@@ -19,7 +19,7 @@ export type TaggingChainOptions = {
  * @param options Options for creating the tagging chain.
  * @returns A new instance of LLMChain configured for tagging.
  */
-export declare function createTaggingChain(schema: FunctionParameters, llm: ChatOpenAI | AnthropicFunctions, options?: TaggingChainOptions): LLMChain<object, ChatOpenAI | AnthropicFunctions>;
+export declare function createTaggingChain(schema: FunctionParameters, llm: BaseChatModel<BaseFunctionCallOptions>, options?: TaggingChainOptions): LLMChain<object, BaseChatModel<BaseFunctionCallOptions>>;
 /**
  * Function that creates a tagging chain from a Zod schema. It converts
  * the Zod schema to a JSON schema using the zodToJsonSchema function and
@@ -29,4 +29,4 @@ export declare function createTaggingChain(schema: FunctionParameters, llm: Chat
  * @param options Options for creating the tagging chain.
  * @returns A new instance of LLMChain configured for tagging.
  */
-export declare function createTaggingChainFromZod(schema: z.ZodObject<any, any, any, any>, llm: ChatOpenAI | AnthropicFunctions, options?: TaggingChainOptions): LLMChain<object, ChatOpenAI | AnthropicFunctions>;
+export declare function createTaggingChainFromZod(schema: z.ZodObject<any, any, any, any>, llm: BaseChatModel<BaseFunctionCallOptions>, options?: TaggingChainOptions): LLMChain<object, BaseChatModel<BaseFunctionCallOptions>>;

package/dist/chains/openai_moderation.cjs

@@ -117,6 +117,7 @@ class OpenAIModerationChain extends base_js_1.BaseChain {
         const output = this._moderate(text, mod.results[0]);
         return {
             [this.outputKey]: output,
+            results: mod.results,
         };
     }
     _chainType() {