langchain 0.0.167 → 0.0.169

package/dist/experimental/chains/violation_of_expectations/violation_of_expectations_chain.js

@@ -0,0 +1,324 @@
+import { JsonOutputFunctionsParser } from "../../../output_parsers/openai_functions.js";
+import { HumanMessage, isBaseMessage, } from "../../../schema/index.js";
+import { StringOutputParser } from "../../../schema/output_parser.js";
+import { BaseChain } from "../../../chains/base.js";
+import { PREDICTION_VIOLATIONS_FUNCTION, PREDICT_NEXT_USER_MESSAGE_FUNCTION, } from "./types.js";
+import { GENERATE_FACTS_PROMPT, GENERATE_REVISED_PREDICTION_PROMPT, PREDICTION_VIOLATIONS_PROMPT, PREDICT_NEXT_USER_MESSAGE_PROMPT, } from "./violation_of_expectations_prompt.js";
+/**
+ * Chain that generates key insights/facts of a user based on a
+ * a chat conversation with an AI.
+ */
+export class ViolationOfExpectationsChain extends BaseChain {
+    static lc_name() {
+        return "ViolationOfExpectationsChain";
+    }
+    _chainType() {
+        return "violation_of_expectation_chain";
+    }
+    get inputKeys() {
+        return [this.chatHistoryKey];
+    }
+    get outputKeys() {
+        return [this.thoughtsKey];
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "chatHistoryKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "chat_history"
+        });
+        Object.defineProperty(this, "thoughtsKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "thoughts"
+        });
+        Object.defineProperty(this, "retriever", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "jsonOutputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stringOutputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.retriever = fields.retriever;
+        this.llm = fields.llm;
+        this.jsonOutputParser = new JsonOutputFunctionsParser();
+        this.stringOutputParser = new StringOutputParser();
+    }
+    getChatHistoryString(chatHistory) {
+        return chatHistory
+            .map((chatMessage) => {
+            if (chatMessage._getType() === "human") {
+                return `Human: ${chatMessage.content}`;
+            }
+            else if (chatMessage._getType() === "ai") {
+                return `AI: ${chatMessage.content}`;
+            }
+            else {
+                return `${chatMessage.content}`;
+            }
+        })
+            .join("\n");
+    }
+    removeDuplicateStrings(strings) {
+        return [...new Set(strings)];
+    }
+    /**
+     * This method breaks down the chat history into chunks of messages.
+     * Each chunk consists of a sequence of messages ending with an AI message and the subsequent user response, if any.
+     *
+     * @param {BaseMessage[]} chatHistory - The chat history to be chunked.
+     *
+     * @returns {MessageChunkResult[]} An array of message chunks. Each chunk includes a sequence of messages and the subsequent user response.
+     *
+     * @description
+     * The method iterates over the chat history and pushes each message into a temporary array.
+     * When it encounters an AI message, it checks for a subsequent user message.
+     * If a user message is found, it is considered as the user response to the AI message.
+     * If no user message is found after the AI message, the user response is undefined.
+     * The method then pushes the chunk (sequence of messages and user response) into the result array.
+     * This process continues until all messages in the chat history have been processed.
+     */
+    chunkMessagesByAIResponse(chatHistory) {
+        const newArray = [];
+        const tempArray = [];
+        chatHistory.forEach((item, index) => {
+            tempArray.push(item);
+            if (item._getType() === "ai") {
+                let userResponse = chatHistory[index + 1];
+                if (!userResponse || userResponse._getType() !== "human") {
+                    userResponse = undefined;
+                }
+                newArray.push({
+                    chunkedMessages: tempArray,
+                    userResponse: userResponse
+                        ? new HumanMessage(userResponse)
+                        : undefined,
+                });
+            }
+        });
+        return newArray;
+    }
+    /**
+     * This method processes a chat history to generate insights about the user.
+     *
+     * @param {ChainValues} values - The input values for the chain. It should contain a key for chat history.
+     * @param {CallbackManagerForChainRun} [runManager] - Optional callback manager for the chain run.
+     *
+     * @returns {Promise<ChainValues>} A promise that resolves to a list of insights about the user.
+     *
+     * @throws {Error} If the chat history key is not found in the input values or if the chat history is not an array of BaseMessages.
+     *
+     * @description
+     * The method performs the following steps:
+     * 1. Checks if the chat history key is present in the input values and if the chat history is an array of BaseMessages.
+     * 2. Breaks the chat history into chunks of messages.
+     * 3. For each chunk, it generates an initial prediction for the user's next message.
+     * 4. For each prediction, it generates insights and prediction violations, and regenerates the prediction based on the violations.
+     * 5. For each set of messages, it generates a fact/insight about the user.
+     * The method returns a list of these insights.
+     */
+    async _call(values, runManager) {
+        if (!(this.chatHistoryKey in values)) {
+            throw new Error(`Chat history key ${this.chatHistoryKey} not found`);
+        }
+        const chatHistory = values[this.chatHistoryKey];
+        const isEveryMessageBaseMessage = chatHistory.every((message) => isBaseMessage(message));
+        if (!isEveryMessageBaseMessage) {
+            throw new Error("Chat history must be an array of BaseMessages");
+        }
+        const messageChunks = this.chunkMessagesByAIResponse(chatHistory);
+        // Generate the initial prediction for every user message.
+        const userPredictions = await Promise.all(messageChunks.map(async (chatHistoryChunk) => ({
+            userPredictions: await this.predictNextUserMessage(chatHistoryChunk.chunkedMessages),
+            userResponse: chatHistoryChunk.userResponse,
+            runManager,
+        })));
+        // Generate insights, and prediction violations for every user message.
+        // This call also regenerates the prediction based on the violations.
+        const predictionViolations = await Promise.all(userPredictions.map((prediction) => this.getPredictionViolations({
+            userPredictions: prediction.userPredictions,
+            userResponse: prediction.userResponse,
+            runManager,
+        })));
+        // Generate a fact/insight about the user for every set of messages.
+        const insights = await Promise.all(predictionViolations.map((violation) => this.generateFacts({
+            userResponse: violation.userResponse,
+            predictions: {
+                revisedPrediction: violation.revisedPrediction,
+                explainedPredictionErrors: violation.explainedPredictionErrors,
+            },
+        })));
+        return {
+            insights,
+        };
+    }
+    /**
+     * This method predicts the next user message based on the chat history.
+     *
+     * @param {BaseMessage[]} chatHistory - The chat history based on which the next user message is predicted.
+     * @param {CallbackManagerForChainRun} [runManager] - Optional callback manager for the chain run.
+     *
+     * @returns {Promise<PredictNextUserMessageResponse>} A promise that resolves to the predicted next user message, the user state, and any insights.
+     *
+     * @throws {Error} If the response from the language model does not contain the expected keys: 'userState', 'predictedUserMessage', and 'insights'.
+     */
+    async predictNextUserMessage(chatHistory, runManager) {
+        const messageString = this.getChatHistoryString(chatHistory);
+        const llmWithFunctions = this.llm.bind({
+            functions: [PREDICT_NEXT_USER_MESSAGE_FUNCTION],
+            function_call: { name: PREDICT_NEXT_USER_MESSAGE_FUNCTION.name },
+        });
+        const chain = PREDICT_NEXT_USER_MESSAGE_PROMPT.pipe(llmWithFunctions).pipe(this.jsonOutputParser);
+        const res = await chain.invoke({
+            chat_history: messageString,
+        }, runManager?.getChild("prediction"));
+        if (!("userState" in res &&
+            "predictedUserMessage" in res &&
+            "insights" in res)) {
+            throw new Error(`Invalid response from LLM: ${JSON.stringify(res)}`);
+        }
+        const predictionResponse = res;
+        // Query the retriever for relevant insights. Use the generates insights as a query.
+        const retrievedDocs = await this.retrieveRelevantInsights(predictionResponse.insights);
+        const relevantDocs = this.removeDuplicateStrings([
+            ...predictionResponse.insights,
+            ...retrievedDocs,
+        ]);
+        return {
+            ...predictionResponse,
+            insights: relevantDocs,
+        };
+    }
+    /**
+     * Retrieves relevant insights based on the provided insights.
+     *
+     * @param {Array<string>} insights - An array of insights to be used for retrieving relevant documents.
+     *
+     * @returns {Promise<Array<string>>} A promise that resolves to an array of relevant insights content.
+     */
+    async retrieveRelevantInsights(insights) {
+        // Only extract the first relevant doc from the retriever. We don't need more than one.
+        const relevantInsightsDocuments = await Promise.all(insights.map(async (insight) => {
+            const relevantInsight = await this.retriever.getRelevantDocuments(insight);
+            return relevantInsight[0];
+        }));
+        const relevantInsightsContent = relevantInsightsDocuments.map((document) => document.pageContent);
+        return relevantInsightsContent;
+    }
+    /**
+     * This method generates prediction violations based on the predicted and actual user responses.
+     * It also generates a revised prediction based on the identified violations.
+     *
+     * @param {Object} params - The parameters for the method.
+     * @param {PredictNextUserMessageResponse} params.userPredictions - The predicted user message, user state, and insights.
+     * @param {BaseMessage} [params.userResponse] - The actual user response.
+     * @param {CallbackManagerForChainRun} [params.runManager] - Optional callback manager for the chain run.
+     *
+     * @returns {Promise<{ userResponse: BaseMessage | undefined; revisedPrediction: string; explainedPredictionErrors: Array<string>; }>} A promise that resolves to an object containing the actual user response, the revised prediction, and the explained prediction errors.
+     *
+     * @throws {Error} If the response from the language model does not contain the expected keys: 'violationExplanation', 'explainedPredictionErrors', and 'accuratePrediction'.
+     */
+    async getPredictionViolations({ userPredictions, userResponse, runManager, }) {
+        const llmWithFunctions = this.llm.bind({
+            functions: [PREDICTION_VIOLATIONS_FUNCTION],
+            function_call: { name: PREDICTION_VIOLATIONS_FUNCTION.name },
+        });
+        const chain = PREDICTION_VIOLATIONS_PROMPT.pipe(llmWithFunctions).pipe(this.jsonOutputParser);
+        const res = (await chain.invoke({
+            predicted_output: userPredictions.predictedUserMessage,
+            actual_output: userResponse?.content ?? "",
+            user_insights: userPredictions.insights.join("\n"),
+        }, runManager?.getChild("prediction_violations")));
+        // Generate a revised prediction based on violations.
+        const revisedPrediction = await this.generateRevisedPrediction({
+            originalPrediction: userPredictions.predictedUserMessage,
+            explainedPredictionErrors: res.explainedPredictionErrors,
+            userInsights: userPredictions.insights,
+            runManager,
+        });
+        return {
+            userResponse,
+            revisedPrediction,
+            explainedPredictionErrors: res.explainedPredictionErrors,
+        };
+    }
+    /**
+     * This method generates a revised prediction based on the original prediction, explained prediction errors, and user insights.
+     *
+     * @param {Object} params - The parameters for the method.
+     * @param {string} params.originalPrediction - The original prediction made by the model.
+     * @param {Array<string>} params.explainedPredictionErrors - An array of explained prediction errors.
+     * @param {Array<string>} params.userInsights - An array of insights about the user.
+     * @param {CallbackManagerForChainRun} [params.runManager] - Optional callback manager for the chain run.
+     *
+     * @returns {Promise<string>} A promise that resolves to a revised prediction.
+     */
+    async generateRevisedPrediction({ originalPrediction, explainedPredictionErrors, userInsights, runManager, }) {
+        const revisedPredictionChain = GENERATE_REVISED_PREDICTION_PROMPT.pipe(this.llm).pipe(this.stringOutputParser);
+        const revisedPredictionRes = await revisedPredictionChain.invoke({
+            prediction: originalPrediction,
+            explained_prediction_errors: explainedPredictionErrors.join("\n"),
+            user_insights: userInsights.join("\n"),
+        }, runManager?.getChild("prediction_revision"));
+        return revisedPredictionRes;
+    }
+    /**
+     * This method generates facts or insights about the user based on the revised prediction, explained prediction errors, and the user's response.
+     *
+     * @param {Object} params - The parameters for the method.
+     * @param {BaseMessage} [params.userResponse] - The actual user response.
+     * @param {Object} params.predictions - The revised prediction and explained prediction errors.
+     * @param {string} params.predictions.revisedPrediction - The revised prediction made by the model.
+     * @param {Array<string>} params.predictions.explainedPredictionErrors - An array of explained prediction errors.
+     * @param {CallbackManagerForChainRun} [params.runManager] - Optional callback manager for the chain run.
+     *
+     * @returns {Promise<string>} A promise that resolves to a string containing the generated facts or insights about the user.
+     */
+    async generateFacts({ userResponse, predictions, runManager, }) {
+        const chain = GENERATE_FACTS_PROMPT.pipe(this.llm).pipe(this.stringOutputParser);
+        const res = await chain.invoke({
+            prediction_violations: predictions.explainedPredictionErrors.join("\n"),
+            prediction: predictions.revisedPrediction,
+            user_message: userResponse?.content ?? "",
+        }, runManager?.getChild("generate_facts"));
+        return res;
+    }
+    /**
+     * Static method that creates a ViolationOfExpectationsChain instance from a
+     * ChatOpenAI and retriever. It also accepts optional options
+     * to customize the chain.
+     *
+     * @param llm The ChatOpenAI instance.
+     * @param retriever The retriever used for similarity search.
+     * @param options Optional options to customize the chain.
+     *
+     * @returns A new instance of ViolationOfExpectationsChain.
+     */
+    static fromLLM(llm, retriever, options) {
+        return new this({
+            retriever,
+            llm,
+            ...options,
+        });
+    }
+}

package/dist/experimental/chains/violation_of_expectations/violation_of_expectations_prompt.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATE_FACTS_PROMPT = exports.GENERATE_REVISED_PREDICTION_PROMPT = exports.PREDICTION_VIOLATIONS_PROMPT = exports.PREDICT_NEXT_USER_MESSAGE_PROMPT = void 0;
+const prompt_js_1 = require("../../../prompts/prompt.cjs");
+exports.PREDICT_NEXT_USER_MESSAGE_PROMPT = 
+/* #__PURE__ */ prompt_js_1.PromptTemplate.fromTemplate(`
+You have been tasked with coming up with insights and data-points based on a chat history between a human and an AI.
+Given the user's chat history provide the following:
+- Concise reasoning about the users internal mental state.
+- Your prediction on how they will respond to the AI's most recent message.
+- A concise list of any additional insights that would be useful to improve prediction.
+--------
+Chat History: {chat_history}`);
+exports.PREDICTION_VIOLATIONS_PROMPT = 
+/* #__PURE__ */ prompt_js_1.PromptTemplate.fromTemplate(`You have been given a prediction and an actual message from a human and AI conversation.
+Using the prediction, actual message, and additional user insights, generate the following:
+- How exactly was the original prediction violated? Which parts were wrong? State the exact differences.
+- If there were errors with the prediction, what were they and why?
+--------
+Predicted Output: {predicted_output}
+--------
+Actual Output: {actual_output}
+--------
+User Insights: {user_insights}
+--------
+`);
+exports.GENERATE_REVISED_PREDICTION_PROMPT = 
+/* #__PURE__ */ prompt_js_1.PromptTemplate.fromTemplate(`
+You have been tasked with revising a prediction on what a user might say in a chat conversation.
+--------
+Your previous prediction: {prediction}
+--------
+Ways in which your prediction was off: {explained_prediction_errors}
+--------
+Key insights to the user: {user_insights}
+--------
+Given the above, revise your prediction to be more accurate.
+Revised Prediction:`);
+exports.GENERATE_FACTS_PROMPT = 
+/* #__PURE__ */ prompt_js_1.PromptTemplate.fromTemplate(`
+Given a user message, an LLM generated prediction of what that message might be, and a list of violations which the prediction made compared to the actual message, generate a fact about the user, relevant to the users message.
+--------
+Prediction violations: {prediction_violations}
+--------
+Revised prediction: {prediction}
+--------
+Actual user message: {user_message}
+--------
+Relevant fact:`);

package/dist/experimental/chains/violation_of_expectations/violation_of_expectations_prompt.d.ts

@@ -0,0 +1,5 @@
+import { PromptTemplate } from "../../../prompts/prompt.js";
+export declare const PREDICT_NEXT_USER_MESSAGE_PROMPT: PromptTemplate<import("../../../prompts/prompt.js").ParamsFromFString<"\nYou have been tasked with coming up with insights and data-points based on a chat history between a human and an AI.\nGiven the user's chat history provide the following:\n- Concise reasoning about the users internal mental state.\n- Your prediction on how they will respond to the AI's most recent message.\n- A concise list of any additional insights that would be useful to improve prediction.\n--------\nChat History: {chat_history}">, any>;
+export declare const PREDICTION_VIOLATIONS_PROMPT: PromptTemplate<import("../../../prompts/prompt.js").ParamsFromFString<"You have been given a prediction and an actual message from a human and AI conversation.\nUsing the prediction, actual message, and additional user insights, generate the following:\n- How exactly was the original prediction violated? Which parts were wrong? State the exact differences.\n- If there were errors with the prediction, what were they and why?\n--------\nPredicted Output: {predicted_output}\n--------\nActual Output: {actual_output}\n--------\nUser Insights: {user_insights}\n--------\n">, any>;
+export declare const GENERATE_REVISED_PREDICTION_PROMPT: PromptTemplate<import("../../../prompts/prompt.js").ParamsFromFString<"\nYou have been tasked with revising a prediction on what a user might say in a chat conversation.\n--------\nYour previous prediction: {prediction}\n--------\nWays in which your prediction was off: {explained_prediction_errors}\n--------\nKey insights to the user: {user_insights}\n--------\nGiven the above, revise your prediction to be more accurate.\nRevised Prediction:">, any>;
+export declare const GENERATE_FACTS_PROMPT: PromptTemplate<import("../../../prompts/prompt.js").ParamsFromFString<"\nGiven a user message, an LLM generated prediction of what that message might be, and a list of violations which the prediction made compared to the actual message, generate a fact about the user, relevant to the users message.\n--------\nPrediction violations: {prediction_violations}\n--------\nRevised prediction: {prediction}\n--------\nActual user message: {user_message}\n--------\nRelevant fact:">, any>;

package/dist/experimental/chains/violation_of_expectations/violation_of_expectations_prompt.js

@@ -0,0 +1,46 @@
+import { PromptTemplate } from "../../../prompts/prompt.js";
+export const PREDICT_NEXT_USER_MESSAGE_PROMPT = 
+/* #__PURE__ */ PromptTemplate.fromTemplate(`
+You have been tasked with coming up with insights and data-points based on a chat history between a human and an AI.
+Given the user's chat history provide the following:
+- Concise reasoning about the users internal mental state.
+- Your prediction on how they will respond to the AI's most recent message.
+- A concise list of any additional insights that would be useful to improve prediction.
+--------
+Chat History: {chat_history}`);
+export const PREDICTION_VIOLATIONS_PROMPT = 
+/* #__PURE__ */ PromptTemplate.fromTemplate(`You have been given a prediction and an actual message from a human and AI conversation.
+Using the prediction, actual message, and additional user insights, generate the following:
+- How exactly was the original prediction violated? Which parts were wrong? State the exact differences.
+- If there were errors with the prediction, what were they and why?
+--------
+Predicted Output: {predicted_output}
+--------
+Actual Output: {actual_output}
+--------
+User Insights: {user_insights}
+--------
+`);
+export const GENERATE_REVISED_PREDICTION_PROMPT = 
+/* #__PURE__ */ PromptTemplate.fromTemplate(`
+You have been tasked with revising a prediction on what a user might say in a chat conversation.
+--------
+Your previous prediction: {prediction}
+--------
+Ways in which your prediction was off: {explained_prediction_errors}
+--------
+Key insights to the user: {user_insights}
+--------
+Given the above, revise your prediction to be more accurate.
+Revised Prediction:`);
+export const GENERATE_FACTS_PROMPT = 
+/* #__PURE__ */ PromptTemplate.fromTemplate(`
+Given a user message, an LLM generated prediction of what that message might be, and a list of violations which the prediction made compared to the actual message, generate a fact about the user, relevant to the users message.
+--------
+Prediction violations: {prediction_violations}
+--------
+Revised prediction: {prediction}
+--------
+Actual user message: {user_message}
+--------
+Relevant fact:`);

package/dist/llms/cloudflare_workersai.cjs

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudflareWorkersAI = void 0;
+const base_js_1 = require("./base.cjs");
+const env_js_1 = require("../util/env.cjs");
+/**
+ * Class representing the CloudflareWorkersAI language model. It extends the LLM (Large
+ * Language Model) class, providing a standard interface for interacting
+ * with the CloudflareWorkersAI language model.
+ */
+class CloudflareWorkersAI extends base_js_1.LLM {
+    static lc_name() {
+        return "CloudflareWorkersAI";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "@cf/meta/llama-2-7b-chat-int8"
+        });
+        Object.defineProperty(this, "cloudflareAccountId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cloudflareApiToken", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.model = fields?.model ?? this.model;
+        this.cloudflareAccountId =
+            fields?.cloudflareAccountId ??
+                (0, env_js_1.getEnvironmentVariable)("CLOUDFLARE_ACCOUNT_ID");
+        this.cloudflareApiToken =
+            fields?.cloudflareApiToken ??
+                (0, env_js_1.getEnvironmentVariable)("CLOUDFLARE_API_TOKEN");
+        this.baseUrl =
+            fields?.baseUrl ??
+                `https://api.cloudflare.com/client/v4/accounts/${this.cloudflareAccountId}/ai/run`;
+        if (this.baseUrl.endsWith("/")) {
+            this.baseUrl = this.baseUrl.slice(0, -1);
+        }
+    }
+    /**
+     * Method to validate the environment.
+     */
+    validateEnvironment() {
+        if (this.baseUrl === undefined) {
+            if (!this.cloudflareAccountId) {
+                throw new Error(`No Cloudflare account ID found. Please provide it when instantiating the CloudflareWorkersAI class, or set it as "CLOUDFLARE_ACCOUNT_ID" in your environment variables.`);
+            }
+            if (!this.cloudflareApiToken) {
+                throw new Error(`No Cloudflare API key found. Please provide it when instantiating the CloudflareWorkersAI class, or set it as "CLOUDFLARE_API_KEY" in your environment variables.`);
+            }
+        }
+    }
+    /** Get the identifying parameters for this LLM. */
+    get identifyingParams() {
+        return { model: this.model };
+    }
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams() {
+        return {
+            model: this.model,
+        };
+    }
+    /** Get the type of LLM. */
+    _llmType() {
+        return "cloudflare";
+    }
+    /** Call out to CloudflareWorkersAI's complete endpoint.
+     Args:
+         prompt: The prompt to pass into the model.
+         Returns:
+     The string generated by the model.
+     Example:
+     let response = CloudflareWorkersAI.call("Tell me a joke.");
+     */
+    async _call(prompt, options) {
+        this.validateEnvironment();
+        const url = `${this.baseUrl}/${this.model}`;
+        const headers = {
+            Authorization: `Bearer ${this.cloudflareApiToken}`,
+            "Content-Type": "application/json",
+        };
+        const data = { prompt };
+        const responseData = await this.caller.call(async () => {
+            const response = await fetch(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(data),
+                signal: options.signal,
+            });
+            if (!response.ok) {
+                const error = new Error(`Cloudflare LLM call failed with status code ${response.status}`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                error.response = response;
+                throw error;
+            }
+            return response.json();
+        });
+        return responseData.result.response;
+    }
+}
+exports.CloudflareWorkersAI = CloudflareWorkersAI;

package/dist/llms/cloudflare_workersai.d.ts

@@ -0,0 +1,49 @@
+import { LLM, BaseLLMParams } from "./base.js";
+/**
+ * Interface for CloudflareWorkersAI input parameters.
+ */
+export interface CloudflareWorkersAIInput {
+    cloudflareAccountId?: string;
+    cloudflareApiToken?: string;
+    model?: string;
+    baseUrl?: string;
+}
+/**
+ * Class representing the CloudflareWorkersAI language model. It extends the LLM (Large
+ * Language Model) class, providing a standard interface for interacting
+ * with the CloudflareWorkersAI language model.
+ */
+export declare class CloudflareWorkersAI extends LLM implements CloudflareWorkersAIInput {
+    model: string;
+    cloudflareAccountId?: string;
+    cloudflareApiToken?: string;
+    baseUrl: string;
+    static lc_name(): string;
+    lc_serializable: boolean;
+    constructor(fields?: CloudflareWorkersAIInput & BaseLLMParams);
+    /**
+     * Method to validate the environment.
+     */
+    validateEnvironment(): void;
+    /** Get the identifying parameters for this LLM. */
+    get identifyingParams(): {
+        model: string;
+    };
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams(): {
+        model: string;
+    };
+    /** Get the type of LLM. */
+    _llmType(): string;
+    /** Call out to CloudflareWorkersAI's complete endpoint.
+     Args:
+         prompt: The prompt to pass into the model.
+         Returns:
+     The string generated by the model.
+     Example:
+     let response = CloudflareWorkersAI.call("Tell me a joke.");
+     */
+    _call(prompt: string, options: this["ParsedCallOptions"]): Promise<string>;
+}