langchain 0.0.155 → 0.0.157

package/dist/chat_models/bedrock.cjs

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatBedrock = exports.convertMessagesToPrompt = exports.convertMessagesToPromptAnthropic = void 0;
+const signature_v4_1 = require("@smithy/signature-v4");
+const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
+const protocol_http_1 = require("@smithy/protocol-http");
+const eventstream_codec_1 = require("@smithy/eventstream-codec");
+const util_utf8_1 = require("@smithy/util-utf8");
+const sha256_js_1 = require("@aws-crypto/sha256-js");
+const bedrock_js_1 = require("../util/bedrock.cjs");
+const env_js_1 = require("../util/env.cjs");
+const base_js_1 = require("./base.cjs");
+const index_js_1 = require("../schema/index.cjs");
+function convertOneMessageToText(message, humanPrompt, aiPrompt) {
+    if (message._getType() === "human") {
+        return `${humanPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "ai") {
+        return `${aiPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "system") {
+        return `${humanPrompt} <admin>${message.content}</admin>`;
+    }
+    else if (index_js_1.ChatMessage.isInstance(message)) {
+        return `\n\n${message.role[0].toUpperCase() + message.role.slice(1)}: {message.content}`;
+    }
+    throw new Error(`Unknown role: ${message._getType()}`);
+}
+function convertMessagesToPromptAnthropic(messages, humanPrompt = "\n\nHuman:", aiPrompt = "\n\nAssistant:") {
+    const messagesCopy = [...messages];
+    if (messagesCopy.length === 0 ||
+        messagesCopy[messagesCopy.length - 1]._getType() !== "ai") {
+        messagesCopy.push(new index_js_1.AIMessage({ content: "" }));
+    }
+    return messagesCopy
+        .map((message) => convertOneMessageToText(message, humanPrompt, aiPrompt))
+        .join("");
+}
+exports.convertMessagesToPromptAnthropic = convertMessagesToPromptAnthropic;
+/**
+ * Function that converts an array of messages into a single string prompt
+ * that can be used as input for a chat model. It delegates the conversion
+ * logic to the appropriate provider-specific function.
+ * @param messages Array of messages to be converted.
+ * @param options Options to be used during the conversion.
+ * @returns A string prompt that can be used as input for a chat model.
+ */
+function convertMessagesToPrompt(messages, provider) {
+    if (provider === "anthropic") {
+        return convertMessagesToPromptAnthropic(messages);
+    }
+    throw new Error(`Provider ${provider} does not support chat.`);
+}
+exports.convertMessagesToPrompt = convertMessagesToPrompt;
+/**
+ * A type of Large Language Model (LLM) that interacts with the Bedrock
+ * service. It extends the base `LLM` class and implements the
+ * `BaseBedrockInput` interface. The class is designed to authenticate and
+ * interact with the Bedrock service, which is a part of Amazon Web
+ * Services (AWS). It uses AWS credentials for authentication and can be
+ * configured with various parameters such as the model to use, the AWS
+ * region, and the maximum number of tokens to generate.
+ */
+class ChatBedrock extends base_js_1.SimpleChatModel {
+    get lc_secrets() {
+        return {};
+    }
+    _llmType() {
+        return "bedrock";
+    }
+    static lc_name() {
+        return "ChatBedrock";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "amazon.titan-tg1-large"
+        });
+        Object.defineProperty(this, "region", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "fetchFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endpointHost", {
+            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, "modelKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new eventstream_codec_1.EventStreamCodec(util_utf8_1.toUtf8, util_utf8_1.fromUtf8)
+        });
+        this.model = fields?.model ?? this.model;
+        const allowedModels = ["ai21", "anthropic", "amazon"];
+        if (!allowedModels.includes(this.model.split(".")[0])) {
+            throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
+        }
+        const region = fields?.region ?? (0, env_js_1.getEnvironmentVariable)("AWS_DEFAULT_REGION");
+        if (!region) {
+            throw new Error("Please set the AWS_DEFAULT_REGION environment variable or pass it to the constructor as the region field.");
+        }
+        this.region = region;
+        this.credentials = fields?.credentials ?? (0, credential_provider_node_1.defaultProvider)();
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.fetchFn = fields?.fetchFn ?? fetch;
+        this.endpointHost = fields?.endpointHost ?? fields?.endpointUrl;
+        this.stopSequences = fields?.stopSequences;
+        this.modelKwargs = fields?.modelKwargs;
+    }
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    async _call(messages, options, runManager) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(messages, options, runManager)) {
+            chunks.push(chunk);
+        }
+        return chunks.map((chunk) => chunk.text).join("");
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock-runtime";
+        const inputBody = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
+        const request = new protocol_http_1.HttpRequest({
+            hostname: url.hostname,
+            path: url.pathname,
+            protocol: url.protocol,
+            method: "POST",
+            body: JSON.stringify(inputBody),
+            query: Object.fromEntries(url.searchParams.entries()),
+            headers: {
+                // host is required by AWS Signature V4: https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+                host: url.host,
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+        });
+        const signer = new signature_v4_1.SignatureV4({
+            credentials: this.credentials,
+            service: "bedrock",
+            region: this.region,
+            sha256: sha256_js_1.Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Send request to AWS using the low-level fetch API
+        const response = await this.caller.callWithOptions({ signal: options.signal }, async () => this.fetchFn(url, {
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+            method: signedRequest.method,
+        }));
+        if (response.status < 200 || response.status >= 300) {
+            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+        }
+        if (provider === "anthropic") {
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            for await (const chunk of this._readChunks(reader)) {
+                const event = this.codec.decode(chunk);
+                if ((event.headers[":event-type"] !== undefined &&
+                    event.headers[":event-type"].value !== "chunk") ||
+                    event.headers[":content-type"].value !== "application/json") {
+                    throw Error(`Failed to get event chunk: got ${chunk}`);
+                }
+                // console.log(decoder.decode(event.body));
+                const body = JSON.parse(decoder.decode(event.body));
+                if (body.message) {
+                    throw new Error(body.message);
+                }
+                if (body.bytes !== undefined) {
+                    const chunkResult = JSON.parse(Buffer.from(body.bytes, "base64").toString());
+                    const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, chunkResult);
+                    yield new index_js_1.ChatGenerationChunk({
+                        text,
+                        message: new index_js_1.AIMessageChunk({ content: text }),
+                    });
+                    await runManager?.handleLLMNewToken(text);
+                }
+            }
+        }
+        else {
+            const json = await response.json();
+            const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+            yield new index_js_1.ChatGenerationChunk({
+                text,
+                message: new index_js_1.AIMessageChunk({ content: text }),
+            });
+            await runManager?.handleLLMNewToken(text);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _readChunks(reader) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                let readResult = await reader.read();
+                while (!readResult.done) {
+                    yield readResult.value;
+                    readResult = await reader.read();
+                }
+            },
+        };
+    }
+    _combineLLMOutput() {
+        return {};
+    }
+}
+exports.ChatBedrock = ChatBedrock;

package/dist/chat_models/bedrock.d.ts

@@ -0,0 +1,58 @@
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { BaseBedrockInput, type CredentialType } from "../util/bedrock.js";
+import { SimpleChatModel, BaseChatModelParams } from "./base.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { BaseMessage, ChatGenerationChunk } from "../schema/index.js";
+export declare function convertMessagesToPromptAnthropic(messages: BaseMessage[], humanPrompt?: string, aiPrompt?: string): string;
+/**
+ * Function that converts an array of messages into a single string prompt
+ * that can be used as input for a chat model. It delegates the conversion
+ * logic to the appropriate provider-specific function.
+ * @param messages Array of messages to be converted.
+ * @param options Options to be used during the conversion.
+ * @returns A string prompt that can be used as input for a chat model.
+ */
+export declare function convertMessagesToPrompt(messages: BaseMessage[], provider: string): string;
+/**
+ * A type of Large Language Model (LLM) that interacts with the Bedrock
+ * service. It extends the base `LLM` class and implements the
+ * `BaseBedrockInput` interface. The class is designed to authenticate and
+ * interact with the Bedrock service, which is a part of Amazon Web
+ * Services (AWS). It uses AWS credentials for authentication and can be
+ * configured with various parameters such as the model to use, the AWS
+ * region, and the maximum number of tokens to generate.
+ */
+export declare class ChatBedrock extends SimpleChatModel implements BaseBedrockInput {
+    model: string;
+    region: string;
+    credentials: CredentialType;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    fetchFn: typeof fetch;
+    endpointHost?: string;
+    stopSequences?: string[];
+    modelKwargs?: Record<string, unknown>;
+    codec: EventStreamCodec;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    _llmType(): string;
+    static lc_name(): string;
+    constructor(fields?: Partial<BaseBedrockInput> & BaseChatModelParams);
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    _call(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _readChunks(reader: any): {
+        [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+    };
+    _combineLLMOutput(): {};
+}

package/dist/chat_models/bedrock.js

@@ -0,0 +1,254 @@
+import { SignatureV4 } from "@smithy/signature-v4";
+import { defaultProvider } from "@aws-sdk/credential-provider-node";
+import { HttpRequest } from "@smithy/protocol-http";
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { BedrockLLMInputOutputAdapter, } from "../util/bedrock.js";
+import { getEnvironmentVariable } from "../util/env.js";
+import { SimpleChatModel } from "./base.js";
+import { AIMessageChunk, AIMessage, ChatGenerationChunk, ChatMessage, } from "../schema/index.js";
+function convertOneMessageToText(message, humanPrompt, aiPrompt) {
+    if (message._getType() === "human") {
+        return `${humanPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "ai") {
+        return `${aiPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "system") {
+        return `${humanPrompt} <admin>${message.content}</admin>`;
+    }
+    else if (ChatMessage.isInstance(message)) {
+        return `\n\n${message.role[0].toUpperCase() + message.role.slice(1)}: {message.content}`;
+    }
+    throw new Error(`Unknown role: ${message._getType()}`);
+}
+export function convertMessagesToPromptAnthropic(messages, humanPrompt = "\n\nHuman:", aiPrompt = "\n\nAssistant:") {
+    const messagesCopy = [...messages];
+    if (messagesCopy.length === 0 ||
+        messagesCopy[messagesCopy.length - 1]._getType() !== "ai") {
+        messagesCopy.push(new AIMessage({ content: "" }));
+    }
+    return messagesCopy
+        .map((message) => convertOneMessageToText(message, humanPrompt, aiPrompt))
+        .join("");
+}
+/**
+ * Function that converts an array of messages into a single string prompt
+ * that can be used as input for a chat model. It delegates the conversion
+ * logic to the appropriate provider-specific function.
+ * @param messages Array of messages to be converted.
+ * @param options Options to be used during the conversion.
+ * @returns A string prompt that can be used as input for a chat model.
+ */
+export function convertMessagesToPrompt(messages, provider) {
+    if (provider === "anthropic") {
+        return convertMessagesToPromptAnthropic(messages);
+    }
+    throw new Error(`Provider ${provider} does not support chat.`);
+}
+/**
+ * A type of Large Language Model (LLM) that interacts with the Bedrock
+ * service. It extends the base `LLM` class and implements the
+ * `BaseBedrockInput` interface. The class is designed to authenticate and
+ * interact with the Bedrock service, which is a part of Amazon Web
+ * Services (AWS). It uses AWS credentials for authentication and can be
+ * configured with various parameters such as the model to use, the AWS
+ * region, and the maximum number of tokens to generate.
+ */
+export class ChatBedrock extends SimpleChatModel {
+    get lc_secrets() {
+        return {};
+    }
+    _llmType() {
+        return "bedrock";
+    }
+    static lc_name() {
+        return "ChatBedrock";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "amazon.titan-tg1-large"
+        });
+        Object.defineProperty(this, "region", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "fetchFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endpointHost", {
+            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, "modelKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new EventStreamCodec(toUtf8, fromUtf8)
+        });
+        this.model = fields?.model ?? this.model;
+        const allowedModels = ["ai21", "anthropic", "amazon"];
+        if (!allowedModels.includes(this.model.split(".")[0])) {
+            throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
+        }
+        const region = fields?.region ?? getEnvironmentVariable("AWS_DEFAULT_REGION");
+        if (!region) {
+            throw new Error("Please set the AWS_DEFAULT_REGION environment variable or pass it to the constructor as the region field.");
+        }
+        this.region = region;
+        this.credentials = fields?.credentials ?? defaultProvider();
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.fetchFn = fields?.fetchFn ?? fetch;
+        this.endpointHost = fields?.endpointHost ?? fields?.endpointUrl;
+        this.stopSequences = fields?.stopSequences;
+        this.modelKwargs = fields?.modelKwargs;
+    }
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    async _call(messages, options, runManager) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(messages, options, runManager)) {
+            chunks.push(chunk);
+        }
+        return chunks.map((chunk) => chunk.text).join("");
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock-runtime";
+        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
+        const request = new HttpRequest({
+            hostname: url.hostname,
+            path: url.pathname,
+            protocol: url.protocol,
+            method: "POST",
+            body: JSON.stringify(inputBody),
+            query: Object.fromEntries(url.searchParams.entries()),
+            headers: {
+                // host is required by AWS Signature V4: https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+                host: url.host,
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+        });
+        const signer = new SignatureV4({
+            credentials: this.credentials,
+            service: "bedrock",
+            region: this.region,
+            sha256: Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Send request to AWS using the low-level fetch API
+        const response = await this.caller.callWithOptions({ signal: options.signal }, async () => this.fetchFn(url, {
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+            method: signedRequest.method,
+        }));
+        if (response.status < 200 || response.status >= 300) {
+            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+        }
+        if (provider === "anthropic") {
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            for await (const chunk of this._readChunks(reader)) {
+                const event = this.codec.decode(chunk);
+                if ((event.headers[":event-type"] !== undefined &&
+                    event.headers[":event-type"].value !== "chunk") ||
+                    event.headers[":content-type"].value !== "application/json") {
+                    throw Error(`Failed to get event chunk: got ${chunk}`);
+                }
+                // console.log(decoder.decode(event.body));
+                const body = JSON.parse(decoder.decode(event.body));
+                if (body.message) {
+                    throw new Error(body.message);
+                }
+                if (body.bytes !== undefined) {
+                    const chunkResult = JSON.parse(Buffer.from(body.bytes, "base64").toString());
+                    const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, chunkResult);
+                    yield new ChatGenerationChunk({
+                        text,
+                        message: new AIMessageChunk({ content: text }),
+                    });
+                    await runManager?.handleLLMNewToken(text);
+                }
+            }
+        }
+        else {
+            const json = await response.json();
+            const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+            yield new ChatGenerationChunk({
+                text,
+                message: new AIMessageChunk({ content: text }),
+            });
+            await runManager?.handleLLMNewToken(text);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _readChunks(reader) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                let readResult = await reader.read();
+                while (!readResult.done) {
+                    yield readResult.value;
+                    readResult = await reader.read();
+                }
+            },
+        };
+    }
+    _combineLLMOutput() {
+        return {};
+    }
+}

package/dist/chat_models/googlevertexai/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoogleVertexAIChatMessage = exports.ChatGoogleVertexAI = void 0;
+exports.ChatGoogleVertexAI = void 0;
 const google_auth_library_1 = require("google-auth-library");
 const common_js_1 = require("./common.cjs");
 const googlevertexai_connection_js_1 = require("../../util/googlevertexai-connection.cjs");
@@ -32,5 +32,3 @@ class ChatGoogleVertexAI extends common_js_1.BaseChatGoogleVertexAI {
     }
 }
 exports.ChatGoogleVertexAI = ChatGoogleVertexAI;
-var common_js_2 = require("./common.cjs");
-Object.defineProperty(exports, "GoogleVertexAIChatMessage", { enumerable: true, get: function () { return common_js_2.GoogleVertexAIChatMessage; } });

package/dist/chat_models/googlevertexai/index.d.ts

@@ -18,4 +18,4 @@ export declare class ChatGoogleVertexAI extends BaseChatGoogleVertexAI<GoogleAut
     static lc_name(): string;
     constructor(fields?: GoogleVertexAIChatInput<GoogleAuthOptions>);
 }
-export { ChatExample, GoogleVertexAIChatAuthor, GoogleVertexAIChatInput, GoogleVertexAIChatInstance, GoogleVertexAIChatMessage, GoogleVertexAIChatMessageFields, GoogleVertexAIChatPrediction, } from "./common.js";
+export type { ChatExample, GoogleVertexAIChatAuthor, GoogleVertexAIChatInput, GoogleVertexAIChatInstance, GoogleVertexAIChatMessage, GoogleVertexAIChatMessageFields, GoogleVertexAIChatPrediction, } from "./common.js";

package/dist/chat_models/googlevertexai/index.js

@@ -28,4 +28,3 @@ export class ChatGoogleVertexAI extends BaseChatGoogleVertexAI {
         this.connection = new GoogleVertexAILLMConnection({ ...fields, ...this }, this.caller, client);
     }
 }
-export { GoogleVertexAIChatMessage, } from "./common.js";

package/dist/chat_models/googlevertexai/web.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoogleVertexAIChatMessage = exports.ChatGoogleVertexAI = void 0;
+exports.ChatGoogleVertexAI = void 0;
 const googlevertexai_connection_js_1 = require("../../util/googlevertexai-connection.cjs");
 const googlevertexai_webauth_js_1 = require("../../util/googlevertexai-webauth.cjs");
 const common_js_1 = require("./common.cjs");
@@ -29,5 +29,3 @@ class ChatGoogleVertexAI extends common_js_1.BaseChatGoogleVertexAI {
     }
 }
 exports.ChatGoogleVertexAI = ChatGoogleVertexAI;
-var common_js_2 = require("./common.cjs");
-Object.defineProperty(exports, "GoogleVertexAIChatMessage", { enumerable: true, get: function () { return common_js_2.GoogleVertexAIChatMessage; } });

package/dist/chat_models/googlevertexai/web.d.ts

@@ -16,4 +16,4 @@ export declare class ChatGoogleVertexAI extends BaseChatGoogleVertexAI<WebGoogle
     };
     constructor(fields?: GoogleVertexAIChatInput<WebGoogleAuthOptions>);
 }
-export { ChatExample, GoogleVertexAIChatAuthor, GoogleVertexAIChatInput, GoogleVertexAIChatInstance, GoogleVertexAIChatMessage, GoogleVertexAIChatMessageFields, GoogleVertexAIChatPrediction, } from "./common.js";
+export type { ChatExample, GoogleVertexAIChatAuthor, GoogleVertexAIChatInput, GoogleVertexAIChatInstance, GoogleVertexAIChatMessage, GoogleVertexAIChatMessageFields, GoogleVertexAIChatPrediction, } from "./common.js";

package/dist/chat_models/googlevertexai/web.js

@@ -25,4 +25,3 @@ export class ChatGoogleVertexAI extends BaseChatGoogleVertexAI {
         this.connection = new GoogleVertexAILLMConnection({ ...fields, ...this }, this.caller, client);
     }
 }
-export { GoogleVertexAIChatMessage, } from "./common.js";

package/dist/chat_models/openai.d.ts

@@ -5,7 +5,7 @@ import { StructuredTool } from "../tools/base.js";
 import { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput, OpenAICoreRequestOptions, LegacyOpenAIInput } from "../types/openai-types.js";
 import { BaseChatModel, BaseChatModelParams } from "./base.js";
 import { BaseFunctionCallOptions } from "../base_language/index.js";
-export { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput };
+export type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput };
 interface TokenUsage {
     completionTokens?: number;
     promptTokens?: number;