@librechat/agents 2.2.2 → 2.2.4

package/dist/types/messages/transformers.d.ts

@@ -1,320 +0,0 @@
-import { Runnable } from "@langchain/core/runnables";
-import type { BaseDocumentTransformer } from "@langchain/core/documents";
-import type { BaseLanguageModel } from "@langchain/core/language_models/base";
-import type { BaseMessage, MessageTypeOrClass } from "@langchain/core/messages";
-interface _TextSplitterInterface extends BaseDocumentTransformer {
-    splitText(text: string): Promise<string[]>;
-}
-export interface TrimMessagesFields {
-    /**
-     * @param {number} maxTokens Max token count of trimmed messages.
-     */
-    maxTokens: number;
-    /**
-     * @param {((messages: BaseMessage[]) => number) | ((messages: BaseMessage[]) => Promise<number>) | BaseLanguageModel} tokenCounter
-     * Function or LLM for counting tokens in an array of `BaseMessage`s.
-     * If a `BaseLanguageModel` is passed in then `BaseLanguageModel.getNumTokens()` will be used.
-     */
-    tokenCounter: ((messages: BaseMessage[]) => number) | ((messages: BaseMessage[]) => Promise<number>) | BaseLanguageModel;
-    /**
-     * @param {"first" | "last"} [strategy="last"] Strategy for trimming.
-     * - "first": Keep the first <= n_count tokens of the messages.
-     * - "last": Keep the last <= n_count tokens of the messages.
-     * @default "last"
-     */
-    strategy?: "first" | "last";
-    /**
-     * @param {boolean} [allowPartial=false] Whether to split a message if only part of the message can be included.
-     * If `strategy: "last"` then the last partial contents of a message are included.
-     * If `strategy: "first"` then the first partial contents of a message are included.
-     * @default false
-     */
-    allowPartial?: boolean;
-    /**
-     * @param {MessageTypeOrClass | MessageTypeOrClass[]} [endOn] The message type to end on.
-     * If specified then every message after the last occurrence of this type is ignored.
-     * If `strategy === "last"` then this is done before we attempt to get the last `maxTokens`.
-     * If `strategy === "first"` then this is done after we get the first `maxTokens`.
-     * Can be specified as string names (e.g. "system", "human", "ai", ...) or as `BaseMessage` classes
-     * (e.g. `SystemMessage`, `HumanMessage`, `AIMessage`, ...). Can be a single type or an array of types.
-     */
-    endOn?: MessageTypeOrClass | MessageTypeOrClass[];
-    /**
-     * @param {MessageTypeOrClass | MessageTypeOrClass[]} [startOn] The message type to start on.
-     * Should only be specified if `strategy: "last"`. If specified then every message before the first occurrence
-     * of this type is ignored. This is done after we trim the initial messages to the last `maxTokens`.
-     * Does not apply to a `SystemMessage` at index 0 if `includeSystem: true`.
-     * Can be specified as string names (e.g. "system", "human", "ai", ...) or as `BaseMessage` classes
-     * (e.g. `SystemMessage`, `HumanMessage`, `AIMessage`, ...). Can be a single type or an array of types.
-     */
-    startOn?: MessageTypeOrClass | MessageTypeOrClass[];
-    /**
-     * @param {boolean} [includeSystem=false] Whether to keep the `SystemMessage` if there is one at index 0.
-     * Should only be specified if `strategy: "last"`.
-     * @default false
-     */
-    includeSystem?: boolean;
-    /**
-     * @param {((text: string) => string[]) | BaseDocumentTransformer} [textSplitter] Function or `BaseDocumentTransformer` for
-     * splitting the string contents of a message. Only used if `allowPartial: true`.
-     * If `strategy: "last"` then the last split tokens from a partial message will be included.
-     * If `strategy: "first"` then the first split tokens from a partial message will be included.
-     * Token splitter assumes that separators are kept, so that split contents can be directly concatenated
-     * to recreate the original text. Defaults to splitting on newlines.
-     */
-    textSplitter?: ((text: string) => string[]) | ((text: string) => Promise<string[]>) | _TextSplitterInterface;
-}
-/**
- * Trim messages to be below a token count.
- *
- * @param {BaseMessage[]} messages Array of `BaseMessage` instances to trim.
- * @param {TrimMessagesFields} options Trimming options.
- * @returns An array of trimmed `BaseMessage`s or a `Runnable` that takes a sequence of `BaseMessage`-like objects and returns
- *     an array of trimmed `BaseMessage`s.
- * @throws {Error} If two incompatible arguments are specified or an unrecognized `strategy` is specified.
- *
- * @example
- * ```typescript
- * import { trimMessages, AIMessage, BaseMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
- *
- * const messages = [
- *   new SystemMessage("This is a 4 token text. The full message is 10 tokens."),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "first",
- *   }),
- *   new AIMessage({
- *     content: [
- *       { type: "text", text: "This is the FIRST 4 token block." },
- *       { type: "text", text: "This is the SECOND 4 token block." },
- *     ],
- *     id: "second",
- *   }),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "third",
- *   }),
- *   new AIMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "fourth",
- *   }),
- * ];
- *
- * function dummyTokenCounter(messages: BaseMessage[]): number {
- *   // treat each message like it adds 3 default tokens at the beginning
- *   // of the message and at the end of the message. 3 + 4 + 3 = 10 tokens
- *   // per message.
- *
- *   const defaultContentLen = 4;
- *   const defaultMsgPrefixLen = 3;
- *   const defaultMsgSuffixLen = 3;
- *
- *   let count = 0;
- *   for (const msg of messages) {
- *     if (typeof msg.content === "string") {
- *       count += defaultMsgPrefixLen + defaultContentLen + defaultMsgSuffixLen;
- *     }
- *     if (Array.isArray(msg.content)) {
- *       count +=
- *         defaultMsgPrefixLen +
- *         msg.content.length * defaultContentLen +
- *         defaultMsgSuffixLen;
- *     }
- *   }
- *   return count;
- * }
- * ```
- *
- * First 30 tokens, not allowing partial messages:
- * ```typescript
- * await trimMessages(messages, {
- *   maxTokens: 30,
- *   tokenCounter: dummyTokenCounter,
- *   strategy: "first",
- * });
- * ```
- *
- * Output:
- * ```typescript
- * [
- *   new SystemMessage(
- *     "This is a 4 token text. The full message is 10 tokens."
- *   ),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "first",
- *   }),
- * ]
- * ```
- *
- * First 30 tokens, allowing partial messages:
- * ```typescript
- * await trimMessages(messages, {
- *   maxTokens: 30,
- *   tokenCounter: dummyTokenCounter,
- *   strategy: "first",
- *   allowPartial: true,
- * });
- * ```
- *
- * Output:
- * ```typescript
- * [
- *   new SystemMessage(
- *     "This is a 4 token text. The full message is 10 tokens."
- *   ),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "first",
- *   }),
- *   new AIMessage({
- *     content: [{ type: "text", text: "This is the FIRST 4 token block." }],
- *     id: "second",
- *   }),
- * ]
- * ```
- *
- * First 30 tokens, allowing partial messages, have to end on HumanMessage:
- * ```typescript
- * await trimMessages(messages, {
- *   maxTokens: 30,
- *   tokenCounter: dummyTokenCounter,
- *   strategy: "first",
- *   allowPartial: true,
- *   endOn: "human",
- * });
- * ```
- *
- * Output:
- * ```typescript
- * [
- *   new SystemMessage(
- *     "This is a 4 token text. The full message is 10 tokens."
- *   ),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "first",
- *   }),
- * ]
- * ```
- *
- * Last 30 tokens, including system message, not allowing partial messages:
- * ```typescript
- * await trimMessages(messages, {
- *   maxTokens: 30,
- *   includeSystem: true,
- *   tokenCounter: dummyTokenCounter,
- *   strategy: "last",
- * });
- * ```
- *
- * Output:
- * ```typescript
- * [
- *   new SystemMessage(
- *     "This is a 4 token text. The full message is 10 tokens."
- *   ),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "third",
- *   }),
- *   new AIMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "fourth",
- *   }),
- * ]
- * ```
- *
- * Last 40 tokens, including system message, allowing partial messages:
- * ```typescript
- * await trimMessages(messages, {
- *   maxTokens: 40,
- *   tokenCounter: dummyTokenCounter,
- *   strategy: "last",
- *   allowPartial: true,
- *   includeSystem: true,
- * });
- * ```
- *
- * Output:
- * ```typescript
- * [
- *   new SystemMessage(
- *     "This is a 4 token text. The full message is 10 tokens."
- *   ),
- *   new AIMessage({
- *     content: [{ type: "text", text: "This is the FIRST 4 token block." }],
- *     id: "second",
- *   }),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "third",
- *   }),
- *   new AIMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "fourth",
- *   }),
- * ]
- * ```
- *
- * Last 30 tokens, including system message, allowing partial messages, end on HumanMessage:
- * ```typescript
- * await trimMessages(messages, {
- *   maxTokens: 30,
- *   tokenCounter: dummyTokenCounter,
- *   strategy: "last",
- *   endOn: "human",
- *   includeSystem: true,
- *   allowPartial: true,
- * });
- * ```
- *
- * Output:
- * ```typescript
- * [
- *   new SystemMessage(
- *     "This is a 4 token text. The full message is 10 tokens."
- *   ),
- *   new AIMessage({
- *     content: [{ type: "text", text: "This is the FIRST 4 token block." }],
- *     id: "second",
- *   }),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "third",
- *   }),
- * ]
- * ```
- *
- * Last 40 tokens, including system message, allowing partial messages, start on HumanMessage:
- * ```typescript
- * await trimMessages(messages, {
- *   maxTokens: 40,
- *   tokenCounter: dummyTokenCounter,
- *   strategy: "last",
- *   includeSystem: true,
- *   allowPartial: true,
- *   startOn: "human",
- * });
- * ```
- *
- * Output:
- * ```typescript
- * [
- *   new SystemMessage(
- *     "This is a 4 token text. The full message is 10 tokens."
- *   ),
- *   new HumanMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "third",
- *   }),
- *   new AIMessage({
- *     content: "This is a 4 token text. The full message is 10 tokens.",
- *     id: "fourth",
- *   }),
- * ]
- * ```
- */
-export declare function trimMessages(options: TrimMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
-export declare function trimMessages(messages: BaseMessage[], options: TrimMessagesFields): Promise<BaseMessage[]>;
-export {};

package/dist/types/messages/trimMessagesFactory.d.ts

@@ -1,37 +0,0 @@
-import { BaseMessage } from "@langchain/core/messages";
-import { TrimMessagesFields } from "./transformers";
-/**
- * Factory function that creates a trimMessages function that maintains an indexTokenCountMap
- * during a run. This allows for efficient token counting by avoiding recounting tokens
- * for messages that have already been processed.
- *
- * @param {Object} options - Configuration options for the trimMessages function
- * @param {TrimMessagesFields} options.trimOptions - Options for the trimMessages function
- * @returns {Function} A function that trims messages while maintaining a token count map
- *
- * @example
- * ```typescript
- * // Create a trimmer function with specific options
- * const trimmer = createTrimMessagesFunction({
- *   trimOptions: {
- *     maxTokens: 4000,
- *     tokenCounter: myTokenCounter,
- *     strategy: "last",
- *     includeSystem: true
- *   }
- * });
- *
- * // Use the trimmer with an array of messages
- * // First call with initial messages
- * const { messages: trimmedMessages1 } = await trimmer(initialMessages);
- *
- * // Later call with additional messages
- * const { messages: trimmedMessages2 } = await trimmer([...initialMessages, ...newMessages]);
- * ```
- */
-export declare function createTrimMessagesFunction({ trimOptions }: {
-    trimOptions: TrimMessagesFields;
-}): (messages: BaseMessage[]) => Promise<{
-    messages: BaseMessage[];
-    indexTokenCountMap: Record<number, number>;
-}>;