Summarize: generate under the chosen profile via profile-switch + reconnect-wait (replaces sendRequest, which ignored the model)

03bd47c310151c3524cab3143c7aef2797018041

permissionBRICK <permissionBRICK@gmail.com>

Parents: 8a47b3fdc48dc9404d14df231a7bfc71cd61f4a0

public/scripts/extensions/memory/index.js+120 -117 Viewed

     extension_prompt_types,
     generateQuietPrompt,
     is_send_press,
 +    online_status,
     saveSettingsDebounced,
     substituteParamsExtended,
     generateRaw,

+    }
+}
 -/**
 +// Warn at most once per session if a summary connection profile is selected but cannot be
 - * Resolve the maximum response length (in tokens) to request from a connection profile.
 +// applied because there is no active connection profile to restore afterward.
 - * Uses the configured override when it is a positive number; otherwise falls back to a
 +let summaryProfileWarnedNoBaseProfile = false;
 - * sensible default cap for a summary.
 - * @returns {number} Maximum tokens for the summary response
 - */
 -function getSummaryProfileMaxTokens() {
 -    const override = Number(extension_settings.memory.overrideResponseLength);
 -    return override > 0 ? override : 1024;
 -}
 /**
  * GenerateRuns a summarycallback usingwith a dedicatedspecific Connection Manager profile instead of thetemporarily active, model.then restores
 - * Assembles the chat transcript (via getRawSummaryPrompt) together with the summary instruction
 + * the previously active profile. This lets the summary be generated by the chosen LLM using the
 - * so the chosen model actually receives the chat to summarize. Honors the configured summary
 + * full summarization pipeline (generateQuietPrompt/generateRaw) under that connection, instead of
  * prompta rolecontext-free byConnection deliveringManager therequest instructionthat assome aproviders SYSTEMrun orwith USERthe messagewrong model.
 - * @param {object} context ST context
 + *
 - * @param {string} profileId Connection Manager profile id
 + * The switch is only performed when a real connection profile is currently active (so it can be
 - * @param {string} prompt Summary instruction
 + * reliably restored). When none is active — i.e. the user drives the API panel manually —
 - * @returns {Promise<{summary: string, index: number}>} Generated summary and the index it covers up to
 + * switching to a profile could not be undone without clobbering those manual settings, so we leave
 + * the active model in place and warn once.
 + *
 + * @param {string} targetProfileId Profile to activate for the duration of the callback.
 + * @param {() => Promise<any>} callback Work to run while the target profile is active.
 + * @returns {Promise<any>} The callback's result.
  */
 async function summarizeWithConnectionProfilewithConnectionProfile(context, profileIdtargetProfileId, promptcallback) {
 -    const { rawPrompt, lastUsedIndex } = await getRawSummaryPrompt(context, prompt);
 +    const select = /** @type {HTMLSelectElement} */ (document.getElementById('connection_profiles'));
+-
 +    const connectionManager = extension_settings.connectionManager;
 -    if (lastUsedIndex === null || lastUsedIndex === -1) {
 +    const currentProfileId = connectionManager?.selectedProfile;
 -        // Nothing to summarize; mirror the raw builder's guard.
++
 -        return { summary: '', index: lastUsedIndex };
 +    const canSwitch = !!select
 +        && !!connectionManager
 +        && Array.isArray(connectionManager.profiles)
 +        && connectionManager.profiles.some(p => p.id === targetProfileId)
 +        && Array.from(select.options).some(o => o.value === targetProfileId)
 +        && !!currentProfileId // a real profile is active, so it can be restored afterwards
 +        && currentProfileId !== targetProfileId;
++
 +    if (!canSwitch) {
 +        // Selected but no base profile to restore from -> use the active model and warn once.
 +        if (targetProfileId && !currentProfileId && !summaryProfileWarnedNoBaseProfile) {
 +            summaryProfileWarnedNoBaseProfile = true;
 +            toastr.info('The summary connection profile is only applied while a connection profile is active (so the original can be restored). Using the current model.', 'Summarize');
 +        }
 +        return await callback();
+    }
     const useUserRoleswitchToProfile = getSummaryPromptRoleasync (profileId) ===> extension_prompt_roles.USER;{
 -    // sendRequest accepts an array of chat-completion messages, so deliver the instruction
 +        const loaded = new Promise(resolve => eventSource.once(event_types.CONNECTION_PROFILE_LOADED, resolve));
 -    // as a separate SYSTEM or USER message (per the configured role) with the transcript as
 +        const timeout = new Promise(resolve => setTimeout(resolve, 10000));
 -    // a USER message. For text-completion profiles these are concatenated downstream.
 +        const index = Array.from(select.options).findIndex(o => o.value === profileId);
 -    const messages = useUserRole
 +        select.selectedIndex = index >= 0 ? index : 0;
 -        ? [{ role: 'user', content: [prompt, rawPrompt].filter(x => x).join('\n\n') }]
 +        select.dispatchEvent(new Event('change'));
 -        : [{ role: 'system', content: prompt }, { role: 'user', content: rawPrompt }];
 +        // Wait for the profile's commands to finish applying (don't hang forever if the event never fires).
 -    const filteredMessages = messages.filter(m => m.content);
 +        await Promise.race([loaded, timeout]);
+-
 +        // Applying a profile reconnects the API asynchronously; generating before it is
 -    const data = await ConnectionManagerRequestService.sendRequest(profileId, filteredMessages, getSummaryProfileMaxTokens());
 +        // re-established fails instantly, so wait for the connection to come back up
 -    // Non-streaming requests resolve to ExtractedData ({ content, reasoning }); extract the plain text.
 +        // (mirrors the built-in /profile command). rejectOnTimeout:false -> proceed anyway after the timeout.
 -    const text = typeof data === 'object' && data !== null ? String(data.content ?? '') : '';
 +        await waitUntilCondition(() => online_status !== 'no_connection', 10000, 100, { rejectOnTimeout: false });
 -    return { summary: removeReasoningFromString(text), index: lastUsedIndex };
 +    };
++
 +    await switchToProfile(targetProfileId);
 +    try {
 +        return await callback();
 +    } finally {
 +        try {
 +            await switchToProfile(currentProfileId);
 +        } catch (err) {
 +            console.error('Summarize: failed to restore the previous connection profile after summarization', err);
 +        }
 +    }
+}
 async function summarizeChatMain(context, force, skipWIAN) {

+    }
     console.log('sending summary prompt');
 -    let summary = '';
 -    let index = null;
+-
 -    // A dedicated connection profile takes precedence over the DEFAULT/RAW builder distinction:
 -    // it always assembles the transcript + instruction and routes through Connection Manager.
 -    const summaryConnectionProfile = extension_settings.memory.summaryConnectionProfile;
 -    if (summaryConnectionProfile) {
 -        let profileSucceeded = false;
 -        try {
 -            inApiCall = true;
 -            const result = await summarizeWithConnectionProfile(context, summaryConnectionProfile, prompt);
+-
 -            if (result.index === null || result.index === -1) {
 -                if (force) {
 -                    toastr.info('To try again, remove the latest summary.', 'No messages found to summarize');
 -                }
 -                return null;
 -            }
+-
 -            summary = result.summary;
 -            index = result.index;
 -            profileSucceeded = true;
 -        } catch (error) {
 -            // Connection Manager disabled, unsupported API, deleted profile, etc.
 -            // Fall back to the regular (active model) path below so summarization still works.
 -            console.warn('Summarize: connection profile failed, falling back to active model', error);
 -        } finally {
 -            inApiCall = false;
 -        }
 -        if (profileSucceeded) {
 +    // Runs the configured summary builder (DEFAULT or RAW) against whatever connection is
 -            if (!summary) {
 +    // currently active. Returns { summary, index }, or null when there is nothing to summarize.
 -                console.warn('Empty summary received');
 +    const runConfiguredSummary = async () => {
 -                return;
 +        let summary = '';
 -            }
 +        let index = null;
 -            if (isContextChanged(context)) {
 +        if (prompt_builders.DEFAULT === extension_settings.memory.prompt_builder) {
 -                return;
 -            }
+-
 -            setMemoryContext(summary, true, index);
 -            return summary;
 -        }
 -    }
+-
 -    if (prompt_builders.DEFAULT === extension_settings.memory.prompt_builder) {
 -        try {
 -            inApiCall = true;
             // generateQuietPrompt always injects the instruction as a SYSTEM message
             // (the QUIET_PROMPT extension prompt has no exposed role parameter).
             // When a USER role is requested, assemble the chat transcript ourselves

                 };
                 summary = await generateQuietPrompt(params);
+            }
 -        } finally {
 -            inApiCall = false;
+        }
 -    }
             if ([prompt_builders.RAW_BLOCKING, prompt_builders.RAW_NON_BLOCKING].includes(extension_settings.memory.prompt_builder)) {
                     const lock = extension_settings.memory.prompt_builder === prompt_builders.RAW_BLOCKING;
                     try {
 -            inApiCall = true;
 +                if (lock) {
 -            if (lock) {
 +                    deactivateSendButtons();
 -                deactivateSendButtons();
 +                }
 -            }
                             const { rawPrompt, lastUsedIndex } = await getRawSummaryPrompt(context, prompt);
                             if (lastUsedIndex === null || lastUsedIndex === -1) {
                                     if (force) {
                                             toastr.info('To try again, remove the latest summary.', 'No messages found to summarize');
+                                    }
                                     return null;
+                            }
                             // When the summary instruction should be a USER message, deliver it as
                             // user content and leave the system prompt empty. Otherwise keep the
                             // existing behavior of sending it as the system prompt.
                             const useUserRole = getSummaryPromptRole() === extension_prompt_roles.USER;
                             /** @type {import('../../../script.js').GenerateRawParams} */
                             const params = {
                                     prompt: useUserRole ? [prompt, rawPrompt].filter(x => x).join('\n\n') : rawPrompt,
                                     systemPrompt: useUserRole ? '' : prompt,
                                     responseLength: extension_settings.memory.overrideResponseLength,
                             };
                             const rawSummary = await generateRaw(params);
                             summary = removeReasoningFromString(rawSummary);
                             index = lastUsedIndex;
                     } finally {
 -            inApiCall = false;
 +                if (lock) {
 -            if (lock) {
 +                    activateSendButtons();
 -                activateSendButtons();
 +                }
+            }
+        }
++
 +        return { summary, index };
 +    };
++
 +    // A dedicated connection profile generates the summary with the chosen LLM by temporarily
 +    // switching the active connection profile (so the full summarization pipeline runs under it),
 +    // then restoring the previous profile. Falls back to the active model when no profile is set
 +    // or no base profile is active to restore.
 +    const summaryConnectionProfile = extension_settings.memory.summaryConnectionProfile;
 +    let result;
 +    try {
 +        inApiCall = true;
 +        result = summaryConnectionProfile
 +            ? await withConnectionProfile(summaryConnectionProfile, runConfiguredSummary)
 +            : await runConfiguredSummary();
 +    } finally {
 +        inApiCall = false;
 +    }
++
 +    if (result === null) {
 +        return null;
+    }
 +    const { summary, index } = result;
++
     if (!summary) {
         console.warn('Empty summary received');
         return;