langchain 0.0.164 → 0.0.166

package/dist/experimental/chat_models/anthropic_functions.d.ts

@@ -1,15 +1,25 @@
-import { BaseChatModelParams } from "../../chat_models/base.js";
+import { BaseChatModel, BaseChatModelParams } from "../../chat_models/base.js";
 import { CallbackManagerForLLMRun } from "../../callbacks/manager.js";
-import { BaseMessage, ChatResult } from "../../schema/index.js";
-import { ChatAnthropic, type AnthropicInput } from "../../chat_models/anthropic.js";
+import { BaseMessage, ChatGenerationChunk, ChatResult } from "../../schema/index.js";
+import { type AnthropicInput } from "../../chat_models/anthropic.js";
 import { BaseFunctionCallOptions } from "../../base_language/index.js";
 import { StructuredTool } from "../../tools/base.js";
 export interface ChatAnthropicFunctionsCallOptions extends BaseFunctionCallOptions {
     tools?: StructuredTool[];
 }
-export declare class AnthropicFunctions extends ChatAnthropic<ChatAnthropicFunctionsCallOptions> {
+export type AnthropicFunctionsInput = Partial<AnthropicInput> & BaseChatModelParams & {
+    llm?: BaseChatModel;
+};
+export declare class AnthropicFunctions extends BaseChatModel<ChatAnthropicFunctionsCallOptions> {
+    llm: BaseChatModel;
+    stopSequences?: string[];
+    lc_namespace: string[];
     static lc_name(): string;
-    constructor(fields?: Partial<AnthropicInput> & BaseChatModelParams);
+    constructor(fields?: AnthropicFunctionsInput);
+    invocationParams(): any;
+    /** @ignore */
+    _identifyingParams(): Record<string, any>;
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
     _llmType(): string;
     /** @ignore */

package/dist/experimental/chat_models/anthropic_functions.js

@@ -1,4 +1,5 @@
 import { XMLParser } from "fast-xml-parser";
+import { BaseChatModel } from "../../chat_models/base.js";
 import { AIMessage, SystemMessage, } from "../../schema/index.js";
 import { ChatAnthropic, DEFAULT_STOP_SEQUENCES, } from "../../chat_models/anthropic.js";
 import { PromptTemplate } from "../../prompts/prompt.js";
@@ -23,12 +24,43 @@ for the weather in SF you would respond:
 
 <tool>search</tool><tool_input><query>weather in SF</query></tool_input>
 <observation>64 degrees</observation>`);
-export class AnthropicFunctions extends ChatAnthropic {
+export class AnthropicFunctions extends BaseChatModel {
     static lc_name() {
         return "AnthropicFunctions";
     }
     constructor(fields) {
         super(fields ?? {});
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "experimental", "chat_models"]
+        });
+        this.llm = fields?.llm ?? new ChatAnthropic(fields);
+        this.stopSequences =
+            fields?.stopSequences ?? this.llm.stopSequences;
+    }
+    invocationParams() {
+        return this.llm.invocationParams();
+    }
+    /** @ignore */
+    _identifyingParams() {
+        return this.llm._identifyingParams();
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        yield* this.llm._streamResponseChunks(messages, options, runManager);
     }
     async _generate(messages, options, runManager) {
         let promptMessages = messages;
@@ -75,7 +107,7 @@ export class AnthropicFunctions extends ChatAnthropic {
         else if (options.function_call !== undefined) {
             throw new Error(`If "function_call" is provided, "functions" must also be.`);
         }
-        const chatResult = await super._generate(promptMessages, options, runManager);
+        const chatResult = await this.llm._generate(promptMessages, options, runManager);
         const chatGenerationContent = chatResult.generations[0].message.content;
         if (forced) {
             const parser = new XMLParser();

package/dist/llms/portkey.cjs

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Portkey = exports.getPortkeySession = exports.PortkeySession = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const portkey_ai_1 = require("portkey-ai");
+const index_js_1 = require("../schema/index.cjs");
+const env_js_1 = require("../util/env.cjs");
+const base_js_1 = require("./base.cjs");
+const readEnv = (env, default_val) => (0, env_js_1.getEnvironmentVariable)(env) ?? default_val;
+class PortkeySession {
+    constructor(options = {}) {
+        Object.defineProperty(this, "portkey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!options.apiKey) {
+            /* eslint-disable no-param-reassign */
+            options.apiKey = readEnv("PORTKEY_API_KEY");
+        }
+        if (!options.baseURL) {
+            /* eslint-disable no-param-reassign */
+            options.baseURL = readEnv("PORTKEY_BASE_URL", "https://api.portkey.ai");
+        }
+        this.portkey = new portkey_ai_1.Portkey({});
+        this.portkey.llms = [{}];
+        if (!options.apiKey) {
+            throw new Error("Set Portkey ApiKey in PORTKEY_API_KEY env variable");
+        }
+        this.portkey = new portkey_ai_1.Portkey(options);
+    }
+}
+exports.PortkeySession = PortkeySession;
+const defaultPortkeySession = [];
+/**
+ * Get a session for the Portkey API. If one already exists with the same options,
+ * it will be returned. Otherwise, a new session will be created.
+ * @param options
+ * @returns
+ */
+function getPortkeySession(options = {}) {
+    let session = defaultPortkeySession.find((session) => lodash_1.default.isEqual(session.options, options))?.session;
+    if (!session) {
+        session = new PortkeySession(options);
+        defaultPortkeySession.push({ session, options });
+    }
+    return session;
+}
+exports.getPortkeySession = getPortkeySession;
+class Portkey extends base_js_1.BaseLLM {
+    constructor(init) {
+        super(init ?? {});
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "baseURL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "mode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "llms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.apiKey = init?.apiKey;
+        this.baseURL = init?.baseURL;
+        this.mode = init?.mode;
+        this.llms = init?.llms;
+        this.session = getPortkeySession({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            llms: this.llms,
+            mode: this.mode,
+        });
+    }
+    _llmType() {
+        return "portkey";
+    }
+    async _generate(prompts, options, _) {
+        const choices = [];
+        for (let i = 0; i < prompts.length; i += 1) {
+            const response = await this.session.portkey.completions.create({
+                prompt: prompts[i],
+                ...options,
+                stream: false,
+            });
+            choices.push(response.choices);
+        }
+        const generations = choices.map((promptChoices) => promptChoices.map((choice) => ({
+            text: choice.text ?? "",
+            generationInfo: {
+                finishReason: choice.finish_reason,
+                logprobs: choice.logprobs,
+            },
+        })));
+        return {
+            generations,
+        };
+    }
+    async *_streamResponseChunks(input, options, runManager) {
+        const response = await this.session.portkey.completions.create({
+            prompt: input,
+            ...options,
+            stream: true,
+        });
+        for await (const data of response) {
+            const choice = data?.choices[0];
+            if (!choice) {
+                continue;
+            }
+            const chunk = new index_js_1.GenerationChunk({
+                text: choice.text ?? "",
+                generationInfo: {
+                    finishReason: choice.finish_reason,
+                },
+            });
+            yield chunk;
+            void runManager?.handleLLMNewToken(chunk.text ?? "");
+        }
+        if (options.signal?.aborted) {
+            throw new Error("AbortError");
+        }
+    }
+}
+exports.Portkey = Portkey;

package/dist/llms/portkey.d.ts

@@ -0,0 +1,33 @@
+import { LLMOptions, Portkey as _Portkey } from "portkey-ai";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { GenerationChunk, LLMResult } from "../schema/index.js";
+import { BaseLLM } from "./base.js";
+interface PortkeyOptions {
+    apiKey?: string;
+    baseURL?: string;
+    mode?: string;
+    llms?: [LLMOptions] | null;
+}
+export declare class PortkeySession {
+    portkey: _Portkey;
+    constructor(options?: PortkeyOptions);
+}
+/**
+ * Get a session for the Portkey API. If one already exists with the same options,
+ * it will be returned. Otherwise, a new session will be created.
+ * @param options
+ * @returns
+ */
+export declare function getPortkeySession(options?: PortkeyOptions): PortkeySession;
+export declare class Portkey extends BaseLLM {
+    apiKey?: string;
+    baseURL?: string;
+    mode?: string;
+    llms?: [LLMOptions] | null;
+    session: PortkeySession;
+    constructor(init?: Partial<Portkey>);
+    _llmType(): string;
+    _generate(prompts: string[], options: this["ParsedCallOptions"], _?: CallbackManagerForLLMRun): Promise<LLMResult>;
+    _streamResponseChunks(input: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
+}
+export {};

package/dist/llms/portkey.js

@@ -0,0 +1,138 @@
+import _ from "lodash";
+import { Portkey as _Portkey } from "portkey-ai";
+import { GenerationChunk } from "../schema/index.js";
+import { getEnvironmentVariable } from "../util/env.js";
+import { BaseLLM } from "./base.js";
+const readEnv = (env, default_val) => getEnvironmentVariable(env) ?? default_val;
+export class PortkeySession {
+    constructor(options = {}) {
+        Object.defineProperty(this, "portkey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!options.apiKey) {
+            /* eslint-disable no-param-reassign */
+            options.apiKey = readEnv("PORTKEY_API_KEY");
+        }
+        if (!options.baseURL) {
+            /* eslint-disable no-param-reassign */
+            options.baseURL = readEnv("PORTKEY_BASE_URL", "https://api.portkey.ai");
+        }
+        this.portkey = new _Portkey({});
+        this.portkey.llms = [{}];
+        if (!options.apiKey) {
+            throw new Error("Set Portkey ApiKey in PORTKEY_API_KEY env variable");
+        }
+        this.portkey = new _Portkey(options);
+    }
+}
+const defaultPortkeySession = [];
+/**
+ * Get a session for the Portkey API. If one already exists with the same options,
+ * it will be returned. Otherwise, a new session will be created.
+ * @param options
+ * @returns
+ */
+export function getPortkeySession(options = {}) {
+    let session = defaultPortkeySession.find((session) => _.isEqual(session.options, options))?.session;
+    if (!session) {
+        session = new PortkeySession(options);
+        defaultPortkeySession.push({ session, options });
+    }
+    return session;
+}
+export class Portkey extends BaseLLM {
+    constructor(init) {
+        super(init ?? {});
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "baseURL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "mode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "llms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.apiKey = init?.apiKey;
+        this.baseURL = init?.baseURL;
+        this.mode = init?.mode;
+        this.llms = init?.llms;
+        this.session = getPortkeySession({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            llms: this.llms,
+            mode: this.mode,
+        });
+    }
+    _llmType() {
+        return "portkey";
+    }
+    async _generate(prompts, options, _) {
+        const choices = [];
+        for (let i = 0; i < prompts.length; i += 1) {
+            const response = await this.session.portkey.completions.create({
+                prompt: prompts[i],
+                ...options,
+                stream: false,
+            });
+            choices.push(response.choices);
+        }
+        const generations = choices.map((promptChoices) => promptChoices.map((choice) => ({
+            text: choice.text ?? "",
+            generationInfo: {
+                finishReason: choice.finish_reason,
+                logprobs: choice.logprobs,
+            },
+        })));
+        return {
+            generations,
+        };
+    }
+    async *_streamResponseChunks(input, options, runManager) {
+        const response = await this.session.portkey.completions.create({
+            prompt: input,
+            ...options,
+            stream: true,
+        });
+        for await (const data of response) {
+            const choice = data?.choices[0];
+            if (!choice) {
+                continue;
+            }
+            const chunk = new GenerationChunk({
+                text: choice.text ?? "",
+                generationInfo: {
+                    finishReason: choice.finish_reason,
+                },
+            });
+            yield chunk;
+            void runManager?.handleLLMNewToken(chunk.text ?? "");
+        }
+        if (options.signal?.aborted) {
+            throw new Error("AbortError");
+        }
+    }
+}

package/dist/llms/sagemaker_endpoint.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SageMakerEndpoint = exports.BaseSageMakerContentHandler = void 0;
 const client_sagemaker_runtime_1 = require("@aws-sdk/client-sagemaker-runtime");
+const index_js_1 = require("../schema/index.cjs");
 const base_js_1 = require("./base.cjs");
 /**
  * A handler class to transform input from LLM to a format that SageMaker
@@ -32,14 +33,12 @@ const base_js_1 = require("./base.cjs");
  */
 class BaseSageMakerContentHandler {
     constructor() {
-        /** The MIME type of the input data passed to endpoint */
         Object.defineProperty(this, "contentType", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "text/plain"
         });
-        /** The MIME type of the response data returned from endpoint */
         Object.defineProperty(this, "accepts", {
             enumerable: true,
             configurable: true,
@@ -51,16 +50,17 @@ class BaseSageMakerContentHandler {
 exports.BaseSageMakerContentHandler = BaseSageMakerContentHandler;
 /**
  * The SageMakerEndpoint class is used to interact with SageMaker
- * Inference Endpoint models. It extends the LLM class and overrides the
- * _call method to transform the input and output between the LLM and the
- * SageMaker endpoint using the provided content handler. The class uses
- * AWS client for authentication, which automatically loads credentials.
+ * Inference Endpoint models. It uses the AWS client for authentication,
+ * which automatically loads credentials.
  * If a specific credential profile is to be used, the name of the profile
  * from the ~/.aws/credentials file must be passed. The credentials or
  * roles used should have the required policies to access the SageMaker
  * endpoint.
  */
 class SageMakerEndpoint extends base_js_1.LLM {
+    static lc_name() {
+        return "SageMakerEndpoint";
+    }
     get lc_secrets() {
         return {
             "clientOptions.credentials.accessKeyId": "AWS_ACCESS_KEY_ID",
@@ -69,39 +69,44 @@ class SageMakerEndpoint extends base_js_1.LLM {
         };
     }
     constructor(fields) {
-        super(fields ?? {});
+        super(fields);
         Object.defineProperty(this, "endpointName", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "contentHandler", {
+        Object.defineProperty(this, "modelKwargs", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modelKwargs", {
+        Object.defineProperty(this, "endpointKwargs", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "endpointKwargs", {
+        Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "client", {
+        Object.defineProperty(this, "contentHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        const regionName = fields.clientOptions.region;
-        if (!regionName) {
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!fields.clientOptions.region) {
             throw new Error(`Please pass a "clientOptions" object with a "region" field to the constructor`);
         }
         const endpointName = fields?.endpointName;
@@ -116,13 +121,33 @@ class SageMakerEndpoint extends base_js_1.LLM {
         this.contentHandler = fields.contentHandler;
         this.endpointKwargs = fields.endpointKwargs;
         this.modelKwargs = fields.modelKwargs;
+        this.streaming = fields.streaming ?? false;
         this.client = new client_sagemaker_runtime_1.SageMakerRuntimeClient(fields.clientOptions);
     }
     _llmType() {
         return "sagemaker_endpoint";
     }
+    /**
+     * Calls the SageMaker endpoint and retrieves the result.
+     * @param {string} prompt The input prompt.
+     * @param {this["ParsedCallOptions"]} options Parsed call options.
+     * @param {CallbackManagerForLLMRun} _runManager Optional run manager.
+     * @returns {Promise<string>} A promise that resolves to the generated string.
+     */
     /** @ignore */
-    async _call(prompt, options) {
+    async _call(prompt, options, _runManager) {
+        return this.streaming
+            ? await this.streamingCall(prompt, options)
+            : await this.noStreamingCall(prompt, options);
+    }
+    async streamingCall(prompt, options) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(prompt, options)) {
+            chunks.push(chunk.text);
+        }
+        return chunks.join("");
+    }
+    async noStreamingCall(prompt, options) {
         const body = await this.contentHandler.transformInput(prompt, this.modelKwargs ?? {});
         const { contentType, accepts } = this.contentHandler;
         const response = await this.caller.call(() => this.client.send(new client_sagemaker_runtime_1.InvokeEndpointCommand({
@@ -137,5 +162,42 @@ class SageMakerEndpoint extends base_js_1.LLM {
         }
         return this.contentHandler.transformOutput(response.Body);
     }
+    /**
+     * Streams response chunks from the SageMaker endpoint.
+     * @param {string} prompt The input prompt.
+     * @param {this["ParsedCallOptions"]} options Parsed call options.
+     * @returns {AsyncGenerator<GenerationChunk>} An asynchronous generator yielding generation chunks.
+     */
+    async *_streamResponseChunks(prompt, options) {
+        const body = await this.contentHandler.transformInput(prompt, this.modelKwargs ?? {});
+        const { contentType, accepts } = this.contentHandler;
+        const stream = await this.caller.call(() => this.client.send(new client_sagemaker_runtime_1.InvokeEndpointWithResponseStreamCommand({
+            EndpointName: this.endpointName,
+            Body: body,
+            ContentType: contentType,
+            Accept: accepts,
+            ...this.endpointKwargs,
+        }), { abortSignal: options.signal }));
+        if (!stream.Body) {
+            throw new Error("Inference result missing Body");
+        }
+        for await (const chunk of stream.Body) {
+            if (chunk.PayloadPart && chunk.PayloadPart.Bytes) {
+                yield new index_js_1.GenerationChunk({
+                    text: await this.contentHandler.transformOutput(chunk.PayloadPart.Bytes),
+                    generationInfo: {
+                        ...chunk,
+                        response: undefined,
+                    },
+                });
+            }
+            else if (chunk.InternalStreamFailure) {
+                throw new Error(chunk.InternalStreamFailure.message);
+            }
+            else if (chunk.ModelStreamError) {
+                throw new Error(chunk.ModelStreamError.message);
+            }
+        }
+    }
 }
 exports.SageMakerEndpoint = SageMakerEndpoint;