langchain 0.0.137 → 0.0.139

package/dist/callbacks/manager.js

@@ -180,11 +180,11 @@ export class CallbackManagerForChainRun extends BaseRunManager {
         }
         return manager;
     }
-    async handleChainError(err) {
+    async handleChainError(err, _runId, _parentRunId, _tags, kwargs) {
         await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
             if (!handler.ignoreChain) {
                 try {
-                    await handler.handleChainError?.(err, this.runId, this._parentRunId, this.tags);
+                    await handler.handleChainError?.(err, this.runId, this._parentRunId, this.tags, kwargs);
                 }
                 catch (err) {
                     console.error(`Error in handler ${handler.constructor.name}, handleChainError: ${err}`);
@@ -192,11 +192,11 @@ export class CallbackManagerForChainRun extends BaseRunManager {
             }
         }, handler.awaitHandlers)));
     }
-    async handleChainEnd(output) {
+    async handleChainEnd(output, _runId, _parentRunId, _tags, kwargs) {
         await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
             if (!handler.ignoreChain) {
                 try {
-                    await handler.handleChainEnd?.(output, this.runId, this._parentRunId, this.tags);
+                    await handler.handleChainEnd?.(output, this.runId, this._parentRunId, this.tags, kwargs);
                 }
                 catch (err) {
                     console.error(`Error in handler ${handler.constructor.name}, handleChainEnd: ${err}`);
@@ -561,40 +561,55 @@ export class TraceGroup {
             value: void 0
         });
     }
-    async getTraceGroupCallbackManager(group_name, options) {
+    async getTraceGroupCallbackManager(group_name, inputs, options) {
         const cb = new LangChainTracer(options);
         const cm = await CallbackManager.configure([cb]);
         const runManager = await cm?.handleChainStart({
             lc: 1,
             type: "not_implemented",
             id: ["langchain", "callbacks", "groups", group_name],
-        }, {});
+        }, inputs ?? {});
         if (!runManager) {
             throw new Error("Failed to create run group callback manager.");
         }
         return runManager;
     }
-    async start() {
+    async start(inputs) {
         if (!this.runManager) {
-            this.runManager = await this.getTraceGroupCallbackManager(this.groupName, this.options);
+            this.runManager = await this.getTraceGroupCallbackManager(this.groupName, inputs, this.options);
         }
         return this.runManager.getChild();
     }
-    async end() {
+    async error(err) {
         if (this.runManager) {
-            await this.runManager.handleChainEnd({});
+            await this.runManager.handleChainError(err);
             this.runManager = undefined;
         }
     }
+    async end(output) {
+        if (this.runManager) {
+            await this.runManager.handleChainEnd(output ?? {});
+            this.runManager = undefined;
+        }
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _coerceToDict(value, defaultKey) {
+    return value && !Array.isArray(value) && typeof value === "object"
+        ? value
+        : { [defaultKey]: value };
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function traceAsGroup(groupOptions, enclosedCode, ...args) {
     const traceGroup = new TraceGroup(groupOptions.name, groupOptions);
-    const callbackManager = await traceGroup.start();
+    const callbackManager = await traceGroup.start({ ...args });
     try {
-        return await enclosedCode(callbackManager, ...args);
+        const result = await enclosedCode(callbackManager, ...args);
+        await traceGroup.end(_coerceToDict(result, "output"));
+        return result;
     }
-    finally {
-        await traceGroup.end();
+    catch (err) {
+        await traceGroup.error(err);
+        throw err;
     }
 }

package/dist/chains/openai_functions/extraction.cjs

@@ -42,7 +42,7 @@ Passage:
  * 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.
  * @param schema JSON schema of the function parameters.
- * @param llm Must be a ChatOpenAI model that supports function calling.
+ * @param llm Must be a ChatOpenAI or AnthropicFunctions model that supports function calling.
  * @returns A LLMChain instance configured to return data matching the schema.
  */
 function createExtractionChain(schema, llm) {
@@ -63,7 +63,7 @@ exports.createExtractionChain = createExtractionChain;
  * converts the Zod schema to a JSON schema using zod-to-json-schema
  * before creating the extraction chain.
  * @param schema The Zod schema which extracted data should match
- * @param llm Must be a ChatOpenAI model that supports function calling.
+ * @param llm Must be a ChatOpenAI or AnthropicFunctions model that supports function calling.
  * @returns A LLMChain instance configured to return data matching the schema.
  */
 function createExtractionChainFromZod(

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

@@ -2,20 +2,21 @@ 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";
 /**
  * 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.
  * @param schema JSON schema of the function parameters.
- * @param llm Must be a ChatOpenAI model that supports function calling.
+ * @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): LLMChain<object, ChatOpenAI>;
+export declare function createExtractionChain(schema: FunctionParameters, llm: ChatOpenAI | AnthropicFunctions): LLMChain<object, ChatOpenAI | AnthropicFunctions>;
 /**
  * Function that creates an extraction chain from a Zod schema. It
  * converts the Zod schema to a JSON schema using zod-to-json-schema
  * before creating the extraction chain.
  * @param schema The Zod schema which extracted data should match
- * @param llm Must be a ChatOpenAI model that supports function calling.
+ * @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): LLMChain<object, ChatOpenAI>;
+export declare function createExtractionChainFromZod(schema: z.ZodObject<any, any, any, any>, llm: ChatOpenAI | AnthropicFunctions): LLMChain<object, ChatOpenAI | AnthropicFunctions>;

package/dist/chains/openai_functions/extraction.js

@@ -39,7 +39,7 @@ Passage:
  * 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.
  * @param schema JSON schema of the function parameters.
- * @param llm Must be a ChatOpenAI model that supports function calling.
+ * @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 function createExtractionChain(schema, llm) {
@@ -59,7 +59,7 @@ export function createExtractionChain(schema, llm) {
  * converts the Zod schema to a JSON schema using zod-to-json-schema
  * before creating the extraction chain.
  * @param schema The Zod schema which extracted data should match
- * @param llm Must be a ChatOpenAI model that supports function calling.
+ * @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 function createExtractionChainFromZod(

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

@@ -4,11 +4,12 @@ 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";
 /**
  * Type representing the options for creating an OpenAPI chain.
  */
 export type OpenAPIChainOptions = {
-    llm?: ChatOpenAI;
+    llm?: ChatOpenAI | AnthropicFunctions;
     prompt?: BasePromptTemplate;
     requestChain?: BaseChain;
     llmChainInputs?: LLMChainInput;

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

@@ -7,6 +7,7 @@ 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";
 /**
  * Type representing the input for creating a structured output chain. It
  * extends the LLMChainInput type and includes an additional
@@ -16,7 +17,7 @@ import { ChatGeneration } from "../../schema/index.js";
 export type StructuredOutputChainInput = Omit<LLMChainInput, "outputParser" | "llm"> & {
     outputSchema: JsonSchema7Type;
     prompt: BasePromptTemplate;
-    llm?: ChatOpenAI;
+    llm?: ChatOpenAI | AnthropicFunctions;
 };
 /**
  * Class that extends the BaseLLMOutputParser class. It provides
@@ -44,5 +45,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>;
-export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput, "outputSchema">): LLMChain<any, ChatOpenAI>;
+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>;

package/dist/chains/openai_functions/tagging.cjs

@@ -30,7 +30,7 @@ Passage:
  * LLM, and options. It constructs the LLM with the necessary
  * functions, prompt, output parser, and tags.
  * @param schema The schema defining the structure of function parameters.
- * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param llm LLM to use in the chain. Must support function calling.
  * @param options Options for creating the tagging chain.
  * @returns A new instance of LLMChain configured for tagging.
  */
@@ -53,7 +53,7 @@ exports.createTaggingChain = createTaggingChain;
  * the Zod schema to a JSON schema using the zodToJsonSchema function and
  * then calls createTaggingChain with the converted schema.
  * @param schema The Zod schema which extracted data should match.
- * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param llm LLM to use in the chain. Must support function calling.
  * @param options Options for creating the tagging chain.
  * @returns A new instance of LLMChain configured for tagging.
  */

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

@@ -3,6 +3,7 @@ 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";
 /**
  * Type representing the options for creating a tagging chain.
  */
@@ -14,18 +15,18 @@ export type TaggingChainOptions = {
  * LLM, and options. It constructs the LLM with the necessary
  * functions, prompt, output parser, and tags.
  * @param schema The schema defining the structure of function parameters.
- * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param llm LLM to use in the chain. Must support function calling.
  * @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, options?: TaggingChainOptions): LLMChain<object, ChatOpenAI>;
+export declare function createTaggingChain(schema: FunctionParameters, llm: ChatOpenAI | AnthropicFunctions, options?: TaggingChainOptions): LLMChain<object, ChatOpenAI | AnthropicFunctions>;
 /**
  * Function that creates a tagging chain from a Zod schema. It converts
  * the Zod schema to a JSON schema using the zodToJsonSchema function and
  * then calls createTaggingChain with the converted schema.
  * @param schema The Zod schema which extracted data should match.
- * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param llm LLM to use in the chain. Must support function calling.
  * @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, options?: TaggingChainOptions): LLMChain<object, ChatOpenAI>;
+export declare function createTaggingChainFromZod(schema: z.ZodObject<any, any, any, any>, llm: ChatOpenAI | AnthropicFunctions, options?: TaggingChainOptions): LLMChain<object, ChatOpenAI | AnthropicFunctions>;

package/dist/chains/openai_functions/tagging.js

@@ -27,7 +27,7 @@ Passage:
  * LLM, and options. It constructs the LLM with the necessary
  * functions, prompt, output parser, and tags.
  * @param schema The schema defining the structure of function parameters.
- * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param llm LLM to use in the chain. Must support function calling.
  * @param options Options for creating the tagging chain.
  * @returns A new instance of LLMChain configured for tagging.
  */
@@ -49,7 +49,7 @@ export function createTaggingChain(schema, llm, options = {}) {
  * the Zod schema to a JSON schema using the zodToJsonSchema function and
  * then calls createTaggingChain with the converted schema.
  * @param schema The Zod schema which extracted data should match.
- * @param llm LLM to use in the chain. Must support OpenAI function calling.
+ * @param llm LLM to use in the chain. Must support function calling.
  * @param options Options for creating the tagging chain.
  * @returns A new instance of LLMChain configured for tagging.
  */

package/dist/chat_models/anthropic.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatAnthropic = void 0;
+exports.ChatAnthropic = exports.DEFAULT_STOP_SEQUENCES = void 0;
 const sdk_1 = require("@anthropic-ai/sdk");
 const index_js_1 = require("../schema/index.cjs");
 const env_js_1 = require("../util/env.cjs");
@@ -41,7 +41,7 @@ function getAnthropicPromptFromMessage(message) {
             throw new Error(`Unknown message type: ${type}`);
     }
 }
-const DEFAULT_STOP_SEQUENCES = [sdk_1.HUMAN_PROMPT];
+exports.DEFAULT_STOP_SEQUENCES = [sdk_1.HUMAN_PROMPT];
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -117,7 +117,7 @@ class ChatAnthropic extends base_js_1.BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "claude-v1"
+            value: "claude-2"
         });
         Object.defineProperty(this, "invocationKwargs", {
             enumerable: true,
@@ -184,9 +184,9 @@ class ChatAnthropic extends base_js_1.BaseChatModel {
             temperature: this.temperature,
             top_k: this.topK,
             top_p: this.topP,
-            stop_sequences: options?.stop?.concat(DEFAULT_STOP_SEQUENCES) ??
+            stop_sequences: options?.stop?.concat(exports.DEFAULT_STOP_SEQUENCES) ??
                 this.stopSequences ??
-                DEFAULT_STOP_SEQUENCES,
+                exports.DEFAULT_STOP_SEQUENCES,
             max_tokens_to_sample: this.maxTokensToSample,
             stream: this.streaming,
             ...this.invocationKwargs,
@@ -308,6 +308,7 @@ class ChatAnthropic extends base_js_1.BaseChatModel {
                 ...this.clientOptions,
                 ...options,
                 apiKey: this.anthropicApiKey,
+                maxRetries: 0,
             });
         }
         const makeCompletionRequest = async () => this.streamingClient.completions.create({ ...request, stream: true }, { headers: request.headers });
@@ -324,6 +325,7 @@ class ChatAnthropic extends base_js_1.BaseChatModel {
                 ...this.clientOptions,
                 ...options,
                 apiKey: this.anthropicApiKey,
+                maxRetries: 0,
             });
         }
         const makeCompletionRequest = async () => this.batchClient.completions.create({ ...request, stream: false }, { headers: request.headers });

package/dist/chat_models/anthropic.d.ts

@@ -1,8 +1,11 @@
 import { Anthropic, ClientOptions } from "@anthropic-ai/sdk";
 import type { CompletionCreateParams } from "@anthropic-ai/sdk/resources/completions";
+import type { Stream } from "@anthropic-ai/sdk/streaming";
 import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
 import { BaseMessage, ChatGenerationChunk, ChatResult } from "../schema/index.js";
 import { BaseChatModel, BaseChatModelParams } from "./base.js";
+import { BaseLanguageModelCallOptions } from "../base_language/index.js";
+export declare const DEFAULT_STOP_SEQUENCES: string[];
 /**
  * Input to AnthropicChat class.
  */
@@ -68,7 +71,7 @@ type Kwargs = Record<string, any>;
  * even if not explicitly available on this class.
  *
  */
-export declare class ChatAnthropic extends BaseChatModel implements AnthropicInput {
+export declare class ChatAnthropic<CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends BaseChatModel<CallOptions> implements AnthropicInput {
     static lc_name(): string;
     get lc_secrets(): {
         [key: string]: string;
@@ -86,8 +89,8 @@ export declare class ChatAnthropic extends BaseChatModel implements AnthropicInp
     stopSequences?: string[];
     streaming: boolean;
     clientOptions: ClientOptions;
-    private batchClient;
-    private streamingClient;
+    protected batchClient: Anthropic;
+    protected streamingClient: Anthropic;
     constructor(fields?: Partial<AnthropicInput> & BaseChatModelParams);
     /**
      * Get the parameters used to invoke the model
@@ -95,28 +98,28 @@ export declare class ChatAnthropic extends BaseChatModel implements AnthropicInp
     invocationParams(options?: this["ParsedCallOptions"]): Omit<CompletionCreateParams, "prompt"> & Kwargs;
     /** @ignore */
     _identifyingParams(): {
-        metadata?: Anthropic.Completions.CompletionCreateParams.CompletionRequestNonStreaming.Metadata | Anthropic.Completions.CompletionCreateParams.CompletionRequestStreaming.Metadata | undefined;
+        metadata?: Anthropic.Completions.CompletionCreateParams.Metadata | undefined;
         stream?: boolean | undefined;
-        model: (string & {}) | "claude-2" | "claude-instant-1";
+        model: "claude-2" | (string & {}) | "claude-instant-1";
         temperature?: number | undefined;
         top_p?: number | undefined;
-        top_k?: number | undefined;
         max_tokens_to_sample: number;
         stop_sequences?: string[] | undefined;
+        top_k?: number | undefined;
         model_name: string;
     };
     /**
      * Get the identifying parameters for the model
      */
     identifyingParams(): {
-        metadata?: Anthropic.Completions.CompletionCreateParams.CompletionRequestNonStreaming.Metadata | Anthropic.Completions.CompletionCreateParams.CompletionRequestStreaming.Metadata | undefined;
+        metadata?: Anthropic.Completions.CompletionCreateParams.Metadata | undefined;
         stream?: boolean | undefined;
-        model: (string & {}) | "claude-2" | "claude-instant-1";
+        model: "claude-2" | (string & {}) | "claude-instant-1";
         temperature?: number | undefined;
         top_p?: number | undefined;
-        top_k?: number | undefined;
         max_tokens_to_sample: number;
         stop_sequences?: string[] | undefined;
+        top_k?: number | undefined;
         model_name: string;
     };
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
@@ -125,7 +128,7 @@ export declare class ChatAnthropic extends BaseChatModel implements AnthropicInp
      * @param messages The base messages to format as a prompt.
      * @returns The formatted prompt.
      */
-    private formatMessagesAsPrompt;
+    protected formatMessagesAsPrompt(messages: BaseMessage[]): string;
     /** @ignore */
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     /**
@@ -133,9 +136,11 @@ export declare class ChatAnthropic extends BaseChatModel implements AnthropicInp
      * @param request The parameters for creating a completion.
      * @returns A streaming request.
      */
-    private createStreamWithRetry;
+    protected createStreamWithRetry(request: CompletionCreateParams & Kwargs): Promise<Stream<Anthropic.Completions.Completion>>;
     /** @ignore */
-    private completionWithRetry;
+    protected completionWithRetry(request: CompletionCreateParams & Kwargs, options: {
+        signal?: AbortSignal;
+    }): Promise<Anthropic.Completions.Completion>;
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(): never[];

package/dist/chat_models/anthropic.js

@@ -38,7 +38,7 @@ function getAnthropicPromptFromMessage(message) {
             throw new Error(`Unknown message type: ${type}`);
     }
 }
-const DEFAULT_STOP_SEQUENCES = [HUMAN_PROMPT];
+export const DEFAULT_STOP_SEQUENCES = [HUMAN_PROMPT];
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -114,7 +114,7 @@ export class ChatAnthropic extends BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "claude-v1"
+            value: "claude-2"
         });
         Object.defineProperty(this, "invocationKwargs", {
             enumerable: true,
@@ -305,6 +305,7 @@ export class ChatAnthropic extends BaseChatModel {
                 ...this.clientOptions,
                 ...options,
                 apiKey: this.anthropicApiKey,
+                maxRetries: 0,
             });
         }
         const makeCompletionRequest = async () => this.streamingClient.completions.create({ ...request, stream: true }, { headers: request.headers });
@@ -321,6 +322,7 @@ export class ChatAnthropic extends BaseChatModel {
                 ...this.clientOptions,
                 ...options,
                 apiKey: this.anthropicApiKey,
+                maxRetries: 0,
             });
         }
         const makeCompletionRequest = async () => this.batchClient.completions.create({ ...request, stream: false }, { headers: request.headers });