node-llama-cpp 3.5.0 → 3.7.0

package/dist/chatWrappers/generic/JinjaTemplateChatWrapper.js

@@ -2,7 +2,16 @@ import { Template } from "@huggingface/jinja";
 import { splitText } from "lifecycle-utils";
 import { SpecialToken, LlamaText, SpecialTokensText } from "../../utils/LlamaText.js";
 import { ChatWrapper } from "../../ChatWrapper.js";
+import { fromChatHistoryToIntermediateOpenAiMessages, fromIntermediateToCompleteOpenAiMessages } from "../../utils/OpenAIFormat.js";
+import { removeUndefinedFields } from "../../utils/removeNullFields.js";
+import { jsonDumps } from "../utils/jsonDumps.js";
+import { tryMatrix } from "../../utils/optionsMatrix.js";
 import { parseFunctionCallMessageTemplate } from "./utils/chatHistoryFunctionCallMessageTemplate.js";
+import { templateSegmentOptionsToChatWrapperSettings } from "./utils/templateSegmentOptionsToChatWrapperSettings.js";
+import { UniqueIdGenerator } from "./utils/UniqueIdGenerator.js";
+import { extractFunctionCallSettingsFromJinjaTemplate } from "./utils/extractFunctionCallSettingsFromJinjaTemplate.js";
+import { squashChatHistoryItems } from "./utils/squashChatHistoryItems.js";
+import { extractSegmentSettingsFromTokenizerAndChatTemplate } from "./utils/extractSegmentSettingsFromTokenizerAndChatTemplate.js";
 const defaultConvertUnsupportedSystemMessagesToUserMessagesFormat = {
     format: "### System message\n\n{{message}}\n\n----"
 };
@@ -25,6 +34,10 @@ const defaultConvertUnsupportedSystemMessagesToUserMessagesFormat = {
  *     // functionCallMessageTemplate: { // optional
  *     //     call: "[[call: {{functionName}}({{functionParams}})]]",
  *     //     result: " [[result: {{functionCallResult}}]]"
+ *     // },
+ *     // segments: {
+ *     //     thoughtTemplate: "<think>{{content}}</think>",
+ *     //     reopenThoughtAfterFunctionCalls: true
  *     // }
  * });
  * ```
@@ -43,11 +56,17 @@ export class JinjaTemplateChatWrapper extends ChatWrapper {
     trimLeadingWhitespaceInResponses;
     additionalRenderParameters;
     /** @internal */ _jinjaTemplate;
+    /** @internal */ _usingJinjaFunctionCallTemplate = false;
+    /** @internal */ _stringifyFunctionParams = false;
+    /** @internal */ _stringifyFunctionResult = false;
+    /** @internal */ _combineJinjaModelMessageAndToolCalls = true;
+    /** @internal */ _endJinjaMessagesWithUserMessage = false;
     /**
      * @param options
      */
-    constructor({ template, modelRoleName = "assistant", userRoleName = "user", systemRoleName = "system", convertUnsupportedSystemMessagesToUserMessages = defaultConvertUnsupportedSystemMessagesToUserMessagesFormat, functionCallMessageTemplate, joinAdjacentMessagesOfTheSameType = true, trimLeadingWhitespaceInResponses = true, additionalRenderParameters }) {
+    constructor(options) {
         super();
+        const { template, modelRoleName = "assistant", userRoleName = "user", systemRoleName = "system", convertUnsupportedSystemMessagesToUserMessages = defaultConvertUnsupportedSystemMessagesToUserMessagesFormat, functionCallMessageTemplate = "auto", joinAdjacentMessagesOfTheSameType = true, trimLeadingWhitespaceInResponses = true, additionalRenderParameters, segments, tokenizer, _requireFunctionCallSettingsExtraction = false } = options;
         if (template == null)
             throw new Error("template cannot be null");
         this.template = template;
@@ -59,50 +78,219 @@ export class JinjaTemplateChatWrapper extends ChatWrapper {
         this.joinAdjacentMessagesOfTheSameType = joinAdjacentMessagesOfTheSameType;
         this.trimLeadingWhitespaceInResponses = trimLeadingWhitespaceInResponses;
         this.additionalRenderParameters = additionalRenderParameters;
-        this.settings = {
-            ...ChatWrapper.defaultSettings,
-            functions: parseFunctionCallMessageTemplate(functionCallMessageTemplate) ?? ChatWrapper.defaultSettings.functions
-        };
         if (this.convertUnsupportedSystemMessagesToUserMessages != null && !this.convertUnsupportedSystemMessagesToUserMessages.format.includes("{{message}}"))
             throw new Error('convertUnsupportedSystemMessagesToUserMessages format must include "{{message}}"');
         this._jinjaTemplate = new Template(this.template);
-        const { supportsSystemMessages } = this._runSanityTest();
+        this.settings = {
+            ...ChatWrapper.defaultSettings,
+            segments: templateSegmentOptionsToChatWrapperSettings(segments)
+        };
+        const { supportsSystemMessages, needsToEndJinjaMessagesWithUserMessage } = this._runSanityTest();
         this.settings = {
             ...this.settings,
-            supportsSystemMessages
+            supportsSystemMessages,
+            segments: {
+                ...this.settings.segments,
+                ...extractSegmentSettingsFromTokenizerAndChatTemplate(this.template, tokenizer)
+            }
         };
+        if (needsToEndJinjaMessagesWithUserMessage)
+            this._endJinjaMessagesWithUserMessage = true;
+        let functionCallSettings = parseFunctionCallMessageTemplate((functionCallMessageTemplate === "auto" || functionCallMessageTemplate === "noJinja")
+            ? undefined
+            : functionCallMessageTemplate);
+        if (functionCallSettings == null && functionCallMessageTemplate !== "noJinja") {
+            try {
+                const idsGenerator = new UniqueIdGenerator(this.template + this.modelRoleName + this.userRoleName + this.systemRoleName +
+                    (this.convertUnsupportedSystemMessagesToUserMessages?.format ?? ""));
+                const extractedSettings = extractFunctionCallSettingsFromJinjaTemplate({
+                    idsGenerator,
+                    renderTemplate: ({ chatHistory, functions, additionalParams, stringifyFunctionParams, stringifyFunctionResults, combineModelMessageAndToolCalls, squashModelTextResponses = true }) => {
+                        const render = (convertSystemMessagesToUserMessagesFormat, wipeFunctionCallIds) => {
+                            const { messages: intermediateMessages, tools } = fromChatHistoryToIntermediateOpenAiMessages({
+                                chatHistory: this._transformChatHistory(chatHistory, {
+                                    convertSystemMessagesToUserMessagesFormat,
+                                    joinAdjacentMessagesOfTheSameType: !squashModelTextResponses
+                                        ? false
+                                        : undefined
+                                }).transformedHistory,
+                                chatWrapperSettings: this.settings,
+                                useRawValues: false,
+                                functions,
+                                stringifyFunctionParams,
+                                stringifyFunctionResults,
+                                combineModelMessageAndToolCalls,
+                                squashModelTextResponses
+                            });
+                            const messages = fromIntermediateToCompleteOpenAiMessages(intermediateMessages)
+                                .map((item) => {
+                                if (!wipeFunctionCallIds)
+                                    return item;
+                                if (item.role === "assistant" && item["tool_calls"] != null && item["tool_calls"].length > 0) {
+                                    for (const toolCall of item["tool_calls"]) {
+                                        if (wipeFunctionCallIds === "align")
+                                            toolCall.id = "fc_1_0001";
+                                        else
+                                            delete toolCall.id;
+                                    }
+                                }
+                                else if (item.role === "tool") {
+                                    if (wipeFunctionCallIds === "align")
+                                        item["tool_call_id"] = "fc_1_0001";
+                                    else
+                                        delete item["tool_call_id"];
+                                }
+                                return item;
+                            });
+                            const lastJinjaItem = messages.at(-1);
+                            let eraseRenderedJinjaFromId;
+                            if (this._endJinjaMessagesWithUserMessage && lastJinjaItem?.role === this.modelRoleName &&
+                                typeof lastJinjaItem.content === "string" &&
+                                lastJinjaItem.content.length > 0 &&
+                                (lastJinjaItem["tool_calls"] == null ||
+                                    lastJinjaItem["tool_calls"]?.length === 0)) {
+                                eraseRenderedJinjaFromId = lastJinjaItem.content;
+                                messages.push({
+                                    role: this.userRoleName,
+                                    content: idsGenerator.generateId()
+                                });
+                            }
+                            let res = this._jinjaTemplate.render({
+                                ...(this.additionalRenderParameters == null
+                                    ? {}
+                                    : structuredClone(this.additionalRenderParameters)),
+                                ...additionalParams,
+                                messages,
+                                ...removeUndefinedFields({ tools })
+                            });
+                            if (eraseRenderedJinjaFromId != null) {
+                                const eraseIndex = res.lastIndexOf(eraseRenderedJinjaFromId);
+                                if (eraseIndex >= 0)
+                                    res = res.slice(0, eraseIndex + eraseRenderedJinjaFromId.length);
+                            }
+                            // attempt to remove the ID pattern from the output
+                            if (wipeFunctionCallIds === "align")
+                                res = res
+                                    .replaceAll(/,\s*"(tool_call_id|call_id|id)":\s*"fc_1_0001"/g, "")
+                                    .replaceAll(/"(tool_call_id|call_id|id)":\s*"fc_1_0001"\s*,/g, "");
+                            return res;
+                        };
+                        return tryMatrix({
+                            convertSystemMessagesToUserMessagesFormat: getConvertUnsupportedSystemMessagesToUserMessagesTryOptions(this.convertUnsupportedSystemMessagesToUserMessages),
+                            wipeFunctionCallIds: [true, "align", false]
+                        }, ({ convertSystemMessagesToUserMessagesFormat, wipeFunctionCallIds }) => {
+                            return render(convertSystemMessagesToUserMessagesFormat, wipeFunctionCallIds);
+                        });
+                    }
+                });
+                functionCallSettings = extractedSettings.settings;
+                if (functionCallSettings != null) {
+                    this._usingJinjaFunctionCallTemplate = true;
+                    this._stringifyFunctionParams = extractedSettings.stringifyParams;
+                    this._stringifyFunctionResult = extractedSettings.stringifyResult;
+                }
+            }
+            catch (err) {
+                // do nothing
+            }
+            if (functionCallSettings == null && _requireFunctionCallSettingsExtraction)
+                throw new Error("failed to extract function call settings from the Jinja template");
+        }
+        this.settings = {
+            ...this.settings,
+            functions: functionCallSettings ?? ChatWrapper.defaultSettings.functions
+        };
+    }
+    /**
+     * Whether the function call syntax settings were extracted from the given Jinja template.
+     *
+     * The function call syntax settings can be accessed using the `.settings.functions` property.
+     */
+    get usingJinjaFunctionCallTemplate() {
+        return this._usingJinjaFunctionCallTemplate;
     }
     generateContextState({ chatHistory, availableFunctions, documentFunctionParams }) {
-        const historyWithFunctions = this.addAvailableFunctionsSystemMessageToHistory(chatHistory, availableFunctions, {
-            documentParams: documentFunctionParams
+        const { contextText, stopGenerationTriggers, ignoreStartText, functionCall, transformedSystemMessagesToUserMessages } = this._generateContextState({
+            chatHistory, availableFunctions, documentFunctionParams,
+            endJinjaMessagesWithUserMessage: this._endJinjaMessagesWithUserMessage
         });
-        if (this.convertUnsupportedSystemMessagesToUserMessages == null) {
-            return this._generateContextText(historyWithFunctions, {
-                convertSystemMessagesToUserMessagesFormat: undefined
-            });
-        }
-        else if (this.convertUnsupportedSystemMessagesToUserMessages.use === "always") {
-            return this._generateContextText(historyWithFunctions, {
-                convertSystemMessagesToUserMessagesFormat: this.convertUnsupportedSystemMessagesToUserMessages.format
-            });
-        }
-        try {
-            return this._generateContextText(historyWithFunctions, {
-                convertSystemMessagesToUserMessagesFormat: undefined
+        return { contextText, stopGenerationTriggers, ignoreStartText, functionCall, transformedSystemMessagesToUserMessages };
+    }
+    addAvailableFunctionsSystemMessageToHistory(history, availableFunctions, options = {}) {
+        if (this._usingJinjaFunctionCallTemplate)
+            return history;
+        return super.addAvailableFunctionsSystemMessageToHistory(history, availableFunctions, options);
+    }
+    generateFunctionCall(name, params) {
+        if (!this._stringifyFunctionParams)
+            return super.generateFunctionCall(name, params);
+        const emptyCallParamsPlaceholder = this.settings.functions.call.emptyCallParamsPlaceholder;
+        return LlamaText([
+            this.settings.functions.call.prefix,
+            name,
+            this.settings.functions.call.paramsPrefix,
+            (params === undefined
+                ? (emptyCallParamsPlaceholder === undefined || emptyCallParamsPlaceholder === "")
+                    ? ""
+                    : JSON.stringify(jsonDumps(emptyCallParamsPlaceholder))
+                : JSON.stringify(jsonDumps(params))),
+            this.settings.functions.call.suffix
+        ]);
+    }
+    generateFunctionCallResult(functionName, functionParams, result) {
+        const resolveParameters = (text) => {
+            return LlamaText(text)
+                .mapValues((value) => {
+                if (typeof value !== "string")
+                    return value;
+                const funcParamsText = functionParams === undefined
+                    ? ""
+                    : jsonDumps(functionParams);
+                return value
+                    .replaceAll("{{functionName}}", functionName)
+                    .replaceAll("{{functionParams}}", (this._stringifyFunctionParams && funcParamsText !== "")
+                    ? JSON.stringify(funcParamsText)
+                    : funcParamsText);
             });
-        }
-        catch (error) {
-            return this._generateContextText(historyWithFunctions, {
-                convertSystemMessagesToUserMessagesFormat: this.convertUnsupportedSystemMessagesToUserMessages.format
+        };
+        const resultText = result === undefined
+            ? "void"
+            : jsonDumps(result);
+        return LlamaText([
+            resolveParameters(this.settings.functions.result.prefix),
+            ((this._stringifyFunctionResult && result !== undefined)
+                ? JSON.stringify(resultText)
+                : resultText),
+            resolveParameters(this.settings.functions.result.suffix)
+        ]);
+    }
+    /** @internal */
+    _generateContextState({ chatHistory, availableFunctions, documentFunctionParams, endJinjaMessagesWithUserMessage }) {
+        return tryMatrix({
+            convertSystemMessagesToUserMessagesFormat: getConvertUnsupportedSystemMessagesToUserMessagesTryOptions(this.convertUnsupportedSystemMessagesToUserMessages),
+            endJinjaMessagesWithUserMessage: endJinjaMessagesWithUserMessage == null
+                ? [false, true]
+                : [endJinjaMessagesWithUserMessage],
+            useMessagesWithEmbeddedTools: this._usingJinjaFunctionCallTemplate
+                ? [undefined, true]
+                : [undefined]
+        }, ({ useMessagesWithEmbeddedTools, endJinjaMessagesWithUserMessage, convertSystemMessagesToUserMessagesFormat }) => {
+            return this._generateContextText(chatHistory, {
+                convertSystemMessagesToUserMessagesFormat, availableFunctions, documentFunctionParams,
+                endJinjaMessagesWithUserMessage,
+                useMessagesWithEmbeddedTools
             });
-        }
+        });
     }
     /** @internal */
-    _generateContextText(history, { convertSystemMessagesToUserMessagesFormat }) {
+    _transformChatHistory(history, { convertSystemMessagesToUserMessagesFormat, availableFunctions, documentFunctionParams = true, joinAdjacentMessagesOfTheSameType = this.joinAdjacentMessagesOfTheSameType }) {
+        const historyWithFunctions = this.addAvailableFunctionsSystemMessageToHistory(history, availableFunctions, {
+            documentParams: documentFunctionParams
+        });
         let transformedSystemMessagesToUserMessages = false;
         const transformedHistory = convertSystemMessagesToUserMessagesFormat == null
-            ? history
-            : history.map((item) => {
+            ? historyWithFunctions
+            : historyWithFunctions.map((item) => {
                 if (item.type === "system") {
                     transformedSystemMessagesToUserMessages = true;
                     return {
@@ -112,58 +300,89 @@ export class JinjaTemplateChatWrapper extends ChatWrapper {
                 }
                 return item;
             });
-        const resultItems = [];
-        const currentTexts = [];
-        let currentAggregateFocus = null;
-        function flush() {
-            if (currentTexts.length > 0 && currentAggregateFocus != null)
-                resultItems.push({ role: currentAggregateFocus, content: LlamaText.joinValues("\n\n", currentTexts) });
-            currentTexts.length = 0;
-        }
-        for (const item of transformedHistory) {
-            if (item.type === "system") {
-                if (!this.joinAdjacentMessagesOfTheSameType || currentAggregateFocus !== "system")
-                    flush();
-                currentAggregateFocus = "system";
-                currentTexts.push(LlamaText.fromJSON(item.text));
-            }
-            else if (item.type === "user") {
-                if (!this.joinAdjacentMessagesOfTheSameType || currentAggregateFocus !== "user")
-                    flush();
-                currentAggregateFocus = "user";
-                currentTexts.push(LlamaText(item.text));
-            }
-            else if (item.type === "model") {
-                if (!this.joinAdjacentMessagesOfTheSameType || currentAggregateFocus !== "model")
-                    flush();
-                currentAggregateFocus = "model";
-                currentTexts.push(this.generateModelResponseText(item.response));
-            }
-            else
+        return {
+            transformedHistory: joinAdjacentMessagesOfTheSameType
+                ? squashChatHistoryItems(transformedHistory)
+                : transformedHistory,
+            transformedSystemMessagesToUserMessages
+        };
+    }
+    /** @internal */
+    _generateContextText(history, { convertSystemMessagesToUserMessagesFormat, availableFunctions, documentFunctionParams = true, endJinjaMessagesWithUserMessage, useMessagesWithEmbeddedTools = false }) {
+        const { transformedSystemMessagesToUserMessages, transformedHistory } = this._transformChatHistory(history, { convertSystemMessagesToUserMessagesFormat, availableFunctions, documentFunctionParams });
+        const generateMessagesWithEmbeddedTools = (chatHistory) => ({
+            messages: chatHistory.map((item) => {
+                if (item.type === "system")
+                    return {
+                        role: "system",
+                        content: LlamaText.fromJSON(item.text)
+                    };
+                else if (item.type === "user")
+                    return {
+                        role: "user",
+                        content: LlamaText(item.text)
+                    };
+                else if (item.type === "model")
+                    return {
+                        role: "assistant",
+                        content: this.generateModelResponseText(item.response)
+                    };
                 void item;
-        }
-        const lastItemIsModelMessage = currentAggregateFocus === "model";
-        flush();
-        const idsGenerator = new UniqueTemplateId(this.template + this.modelRoleName + this.userRoleName + this.systemRoleName +
-            (convertSystemMessagesToUserMessagesFormat ?? "") + resultItems.map(({ content }) => content.toString()).join("\n\n"));
+                return { role: "user", content: LlamaText("") };
+            }),
+            tools: undefined
+        });
+        const generateMessagesWithTools = (chatHistory) => (fromChatHistoryToIntermediateOpenAiMessages({
+            chatHistory,
+            chatWrapperSettings: this.settings,
+            useRawValues: false,
+            functions: (availableFunctions != null && !documentFunctionParams)
+                ? Object.fromEntries(Object.entries(availableFunctions)
+                    .map(([funcName, { description, ...func }]) => [funcName, func]))
+                : availableFunctions,
+            stringifyFunctionParams: this._stringifyFunctionParams,
+            stringifyFunctionResults: this._stringifyFunctionResult,
+            combineModelMessageAndToolCalls: this._combineJinjaModelMessageAndToolCalls
+        }));
+        const lastItemIsModelMessage = transformedHistory.at(-1)?.type === "model";
+        const { messages: intermediateMessages, tools } = this._usingJinjaFunctionCallTemplate
+            ? useMessagesWithEmbeddedTools
+                ? {
+                    messages: generateMessagesWithEmbeddedTools(transformedHistory).messages,
+                    tools: generateMessagesWithTools(transformedHistory).tools
+                }
+                : generateMessagesWithTools(transformedHistory)
+            : generateMessagesWithEmbeddedTools(transformedHistory);
+        const idsGenerator = new UniqueIdGenerator(this.template + this.modelRoleName + this.userRoleName + this.systemRoleName +
+            (convertSystemMessagesToUserMessagesFormat ?? "") +
+            intermediateMessages.map(({ content }) => (content?.toString() ?? "")).join("\n\n"));
         const jinjaItems = [];
         const jinjaRoleMap = {
             system: this.systemRoleName,
             user: this.userRoleName,
-            model: this.modelRoleName
+            assistant: this.modelRoleName,
+            tool: "tool"
         };
         const idToContent = new Map();
         const modelMessageIds = new Set();
         const messageIds = new Set();
-        for (const resultItem of resultItems) {
-            const id = idsGenerator.generateId();
+        for (const intermediateMessage of intermediateMessages) {
+            if (intermediateMessage.content == null) {
+                jinjaItems.push({
+                    ...intermediateMessage,
+                    role: jinjaRoleMap[intermediateMessage.role] ?? intermediateMessage.role
+                });
+                continue;
+            }
+            const id = idsGenerator.generateId(intermediateMessage.role === "tool");
             messageIds.add(id);
-            idToContent.set(id, resultItem.content);
+            idToContent.set(id, LlamaText(intermediateMessage.content));
             jinjaItems.push({
-                role: jinjaRoleMap[resultItem.role],
+                ...intermediateMessage,
+                role: jinjaRoleMap[intermediateMessage.role] ?? intermediateMessage.role,
                 content: id
             });
-            if (resultItem.role === "model")
+            if (intermediateMessage.role === "assistant" || intermediateMessage.role === "tool")
                 modelMessageIds.add(id);
         }
         const bosTokenId = idsGenerator.generateId();
@@ -172,41 +391,39 @@ export class JinjaTemplateChatWrapper extends ChatWrapper {
         idToContent.set(bosTokenId, new SpecialToken("BOS"));
         idToContent.set(eosTokenId, new SpecialToken("EOS"));
         idToContent.set(eotTokenId, new SpecialToken("EOT"));
-        function tryOptions(options) {
-            for (let i = 0; i < options.length; i++) {
-                if (i === options.length - 1)
-                    return options[i]();
-                try {
-                    return options[i]();
-                }
-                catch (err) {
-                    // do nothing
-                }
-            }
-            throw new Error("All options failed");
+        const lastJinjaItem = jinjaItems.at(-1);
+        let eraseRenderedJinjaFromId;
+        if (endJinjaMessagesWithUserMessage && lastJinjaItem?.role === this.modelRoleName &&
+            typeof lastJinjaItem.content === "string" &&
+            lastJinjaItem.content.length > 0 &&
+            (lastJinjaItem["tool_calls"] == null ||
+                lastJinjaItem["tool_calls"]?.length === 0)) {
+            eraseRenderedJinjaFromId = lastJinjaItem.content;
+            jinjaItems.push({
+                role: this.userRoleName,
+                content: idsGenerator.generateId()
+            });
         }
         const renderJinjaText = () => {
-            return tryOptions([
-                () => this._jinjaTemplate.render({
-                    ...(this.additionalRenderParameters == null
-                        ? {}
-                        : structuredClone(this.additionalRenderParameters)),
-                    messages: jinjaItems,
-                    "bos_token": bosTokenId,
-                    "eos_token": eosTokenId,
-                    "eot_token": eotTokenId
-                }),
-                () => this._jinjaTemplate.render({
-                    ...(this.additionalRenderParameters == null
-                        ? {}
-                        : structuredClone(this.additionalRenderParameters)),
-                    messages: jinjaItems,
-                    "bos_token": bosTokenId,
-                    "eos_token": eosTokenId,
-                    "eot_token": eotTokenId,
-                    "add_generation_prompt": true
-                })
-            ]);
+            let res = tryMatrix({
+                options: [{}, { "add_generation_prompt": true }]
+            }, ({ options }) => (this._jinjaTemplate.render({
+                ...(this.additionalRenderParameters == null
+                    ? {}
+                    : structuredClone(this.additionalRenderParameters)),
+                messages: jinjaItems,
+                ...removeUndefinedFields({ tools }),
+                "bos_token": bosTokenId,
+                "eos_token": eosTokenId,
+                "eot_token": eotTokenId,
+                ...options
+            })));
+            if (eraseRenderedJinjaFromId != null) {
+                const eraseIndex = res.lastIndexOf(eraseRenderedJinjaFromId);
+                if (eraseIndex >= 0)
+                    res = res.slice(0, eraseIndex + eraseRenderedJinjaFromId.length);
+            }
+            return res;
         };
         const validateThatAllMessageIdsAreUsed = (parts) => {
             const messageIdsLeft = new Set(messageIds);
@@ -290,48 +507,41 @@ export class JinjaTemplateChatWrapper extends ChatWrapper {
                         }))
                     ])
             ],
-            transformedSystemMessagesToUserMessages
+            transformedSystemMessagesToUserMessages,
+            endJinjaMessagesWithUserMessage
         };
     }
     /**
      * Validate that this Jinja template can be rendered
      * @internal
      */
-    _runSanityTest() {
+    _runSanityTest(needsToEndJinjaMessagesWithUserMessage = false) {
         try {
             let supportsSystemMessages = true;
             for (const chatHistory of chatHistoriesForSanityTest) {
-                const { transformedSystemMessagesToUserMessages } = this.generateContextState({ chatHistory });
+                const { transformedSystemMessagesToUserMessages, endJinjaMessagesWithUserMessage: endedJinjaMessagesWithUserMessage } = this._generateContextState({
+                    chatHistory,
+                    endJinjaMessagesWithUserMessage: needsToEndJinjaMessagesWithUserMessage
+                        ? true
+                        : undefined
+                });
                 if (transformedSystemMessagesToUserMessages)
                     supportsSystemMessages = false;
+                if (!needsToEndJinjaMessagesWithUserMessage && endedJinjaMessagesWithUserMessage) {
+                    if (chatHistory !== chatHistoriesForSanityTest[0])
+                        // validate tha this doesn't break the template
+                        return this._runSanityTest(true);
+                    else
+                        needsToEndJinjaMessagesWithUserMessage = true;
+                }
             }
-            return { supportsSystemMessages };
+            return { supportsSystemMessages, needsToEndJinjaMessagesWithUserMessage };
         }
         catch (err) {
             throw new Error("The provided Jinja template failed the sanity test: " + String(err) + ". Inspect the Jinja template to find out what went wrong");
         }
     }
 }
-class UniqueTemplateId {
-    antiText;
-    _ids = new Set();
-    constructor(antiText) {
-        this.antiText = antiText;
-    }
-    generateId() {
-        let id;
-        do {
-            id = "W" + (Math.random()
-                .toString(36)
-                .slice(2)) + "W";
-        } while (this._ids.has(id) || this.antiText.includes(id));
-        this._ids.add(id);
-        return id;
-    }
-    removeId(id) {
-        this._ids.delete(id);
-    }
-}
 function resolveConvertUnsupportedSystemMessagesToUserMessagesOption(convertUnsupportedSystemMessagesToUserMessages) {
     if (convertUnsupportedSystemMessagesToUserMessages === false)
         return undefined;
@@ -352,6 +562,13 @@ function resolveConvertUnsupportedSystemMessagesToUserMessagesOption(convertUnsu
         };
     return { ...defaultConvertUnsupportedSystemMessagesToUserMessagesFormat, use: "ifNeeded" };
 }
+function getConvertUnsupportedSystemMessagesToUserMessagesTryOptions(convertUnsupportedSystemMessagesToUserMessages) {
+    if (convertUnsupportedSystemMessagesToUserMessages == null)
+        return [undefined];
+    else if (convertUnsupportedSystemMessagesToUserMessages.use === "always")
+        return [convertUnsupportedSystemMessagesToUserMessages.format];
+    return [undefined, convertUnsupportedSystemMessagesToUserMessages.format];
+}
 const chatHistoriesForSanityTest = [
     [{
             type: "system",