MagicalAstrogy · MagicalAstrogy · Jun 20, 2026 · Jun 20, 2026 · Jun 20, 2026 · chatgpt-codex-connector
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 2026-06-20
+## 体验改进
+ - 现在支持调整在额外模型解析过程中，提供的消息楼层数。默认为 2。
+ - 增加了应答格式 `格式化输出(v4兼容)`, 用于 官deepseek-v4 等渠道。（注：如果同时使用其他包含额外解析的插件，可能会有兼容性问题）
+ -
 # 2026-04-25
 ## 体验改进
  - 现在额外模型解析支持指定当前环境下的已有预设，代表使用那个预设的提示词结构，api/预设脚本/正则 等依然使用当前预设/手动指定的。

diff --git a/src/function/update/invoke_extra_model.ts b/src/function/update/invoke_extra_model.ts
@@ -21,15 +21,143 @@ import { useDataStore } from '@/store';
 import { normalizeBaseURL } from '@/util';
 import { literalYamlify, uuidv4 } from '@util/common';
 import { compare } from 'compare-versions';
+import YAML from 'yaml';
 
 //测试用，为了使首次请求必失败
 let debug_extra_request_counter = 0;
 
+const V4_COMPATIBLE_FORMATTED_OUTPUT = '格式化输出(v4兼容)';
+const JSON_OBJECT_CUSTOM_INCLUDE_BODY = Object.freeze({
+    response_format: {
+        type: 'json_object',
+    },
+});
+const DISABLED_THINKING_CUSTOM_INCLUDE_BODY = Object.freeze({
+    thinking: {
+        type: 'disabled',
+    },
+});
+
 function generateRandomHeader(): string {
     return _.times(4, () => uuidv4().slice(0, 8)).join('\n');
 }
 
-function setExtraAnalysisStates() {
+function isV4CompatibleFormattedOutput(): boolean {
+    return useDataStore().settings.额外模型解析配置.应答格式 === V4_COMPATIBLE_FORMATTED_OUTPUT;
+}
+
+function assertV4CompatibleFormattedOutputUsable() {
+    const store = useDataStore();
+    if (
+        store.settings.额外模型解析配置.应答格式 === V4_COMPATIBLE_FORMATTED_OUTPUT &&
+        store.settings.额外模型解析配置.模型来源 === '与插头相同'
+    ) {
+        throw new Error(
+            '[MVU额外模型解析]格式化输出(v4兼容)需要额外模型来源为自定义，不能与插头相同。'
+        );
+    }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function parseCustomIncludeBody(body: unknown): Record<string, unknown> {
+    if (typeof body !== 'string' || body.trim() === '') {
+        return {};
+    }
+
+    const parsed = YAML.parse(body);
+    if (isPlainObject(parsed)) {
+        return parsed;
+    }
+    if (Array.isArray(parsed)) {
+        return Object.assign({}, ...parsed.filter(isPlainObject));
+    }
+    throw new Error('[MVU额外模型解析]custom_include_body 不是 YAML object，无法合并配置。');
+}
+
+function buildJsonObjectCustomIncludeBody(original_body: unknown): string {
+    const store = useDataStore();
+    return YAML.stringify({
+        ...parseCustomIncludeBody(original_body),
+        ...JSON_OBJECT_CUSTOM_INCLUDE_BODY,
+        ...(store.settings.额外模型解析配置.关闭thinking
+            ? DISABLED_THINKING_CUSTOM_INCLUDE_BODY
+            : {}),
+    }).trimEnd();
+}
+
+async function saveSillyTavernSettings() {
+    const save_settings =
+        typeof builtin === 'undefined' ? undefined : builtin.saveSettings.bind(builtin);
+    if (typeof save_settings !== 'function') {
+        throw new Error('[MVU额外模型解析]无法获取 SillyTavern saveSettings，不能临时更新配置。');
+    }
+    await save_settings();
+}
+
+let temporary_json_object_response_format_state: {
+    had_original_body: boolean;
+    original_body: unknown;
+} | null = null;
+
+async function setTemporaryJsonObjectResponseFormat() {
+    if (!isV4CompatibleFormattedOutput()) {
+        temporary_json_object_response_format_state = null;
+        return;
+    }
+
+    assertV4CompatibleFormattedOutputUsable();
+    const oai_settings = SillyTavern.chatCompletionSettings;
+    if (!isPlainObject(oai_settings)) {
+        throw new Error('[MVU额外模型解析]无法获取 SillyTavern OpenAI 设置。');
+    }
+
+    const had_original_body = Object.prototype.hasOwnProperty.call(
+        oai_settings,
+        'custom_include_body'
+    );
+    const original_body = oai_settings.custom_include_body;
+    oai_settings.custom_include_body = buildJsonObjectCustomIncludeBody(original_body);
+    try {
+        await saveSillyTavernSettings();
+        temporary_json_object_response_format_state = {
+            had_original_body,
+            original_body,
+        };
+    } catch (error) {
+        if (had_original_body) {
+            oai_settings.custom_include_body = original_body;
+        } else {
+            delete oai_settings.custom_include_body;
+        }
+        temporary_json_object_response_format_state = null;
+        throw error;
+    }
+}
+
+async function restoreTemporaryJsonObjectResponseFormat() {
+    if (!temporary_json_object_response_format_state) {
+        return;
+    }
+
+    const oai_settings = SillyTavern.chatCompletionSettings;
+    if (!isPlainObject(oai_settings)) {
+        throw new Error('[MVU额外模型解析]无法获取 SillyTavern OpenAI 设置，不能恢复配置。');
+    }
+
+    const { had_original_body, original_body } = temporary_json_object_response_format_state;
+    temporary_json_object_response_format_state = null;
+    if (had_original_body) {
+        oai_settings.custom_include_body = original_body;
+    } else {
+        delete oai_settings.custom_include_body;
+    }
+    await saveSillyTavernSettings();
+}
+
+async function setExtraAnalysisStates() {
     const store = useDataStore();
 
     if (store.runtimes.is_during_extra_analysis === true) {
@@ -41,15 +169,25 @@ function setExtraAnalysisStates() {
     //因为这个操作是幂等的，所以无所谓。
 
     store.runtimes.is_during_extra_analysis = true;
+    try {
+        await setTemporaryJsonObjectResponseFormat();
+    } catch (error) {
+        store.runtimes.is_during_extra_analysis = false;
+        throw error;
+    }
 }
 
-function unsetExtraAnalysisStates() {
+async function unsetExtraAnalysisStates() {
     const store = useDataStore();
 
     SillyTavern.unregisterMacro('lastUserMessage');
     clearExtraModelRequestOverrides();
-    store.runtimes.is_during_extra_analysis = false;
     store.runtimes.is_function_call_enabled = false;
+    try {
+        await restoreTemporaryJsonObjectResponseFormat();
+    } finally {
+        store.runtimes.is_during_extra_analysis = false;
+    }
 }
 
 let is_analysis_in_progress = false;
@@ -78,28 +216,36 @@ export async function invokeExtraModelWithStrategy(): Promise<string | null> {
             is_manual_canceled: boolean;
         }> => {
             let is_manual_canceled = false;
+            let did_set_extra_analysis_states = false;
             try {
-                setExtraAnalysisStates();
+                await setExtraAnalysisStates();
+                did_set_extra_analysis_states = true;
                 return { result: await recordedInvoke(), is_manual_canceled: false };
             } catch (e) {
                 /** 已经记录, 忽略 */
                 if (e === 'Clicked stop button') is_manual_canceled = true;
             } finally {
-                unsetExtraAnalysisStates();
+                if (did_set_extra_analysis_states) {
+                    await unsetExtraAnalysisStates();
+                }
             }
             return { result: null, is_manual_canceled: is_manual_canceled };
         };
         const concurrentInvoke = async (times: number) => {
             const uuids = _.times(times, uuidv4);
+            let did_set_extra_analysis_states = false;
             try {
-                setExtraAnalysisStates();
+                await setExtraAnalysisStates();
+                did_set_extra_analysis_states = true;
                 //在函数调用的模式下，允许接受 **任意** 有效的函数结果，因此被允许被覆盖。
                 return await Promise.any(uuids.map(recordedInvoke));
             } catch (e) {
                 /** 已经记录, 忽略 */
             } finally {
                 uuids.forEach(stopGenerationById);
-                unsetExtraAnalysisStates();
+                if (did_set_extra_analysis_states) {
+                    await unsetExtraAnalysisStates();
+                }
             }
             return null;
         };
@@ -152,6 +298,8 @@ export async function invokeExtraModelWithStrategy(): Promise<string | null> {
                     );
                 }
                 return concurrentInvoke(store.settings.额外模型解析配置.请求次数 - 1);
+            default:
+                return null;
         }
     } finally {
         is_analysis_in_progress = false;
@@ -162,11 +310,15 @@ export async function invokeExtraModelWithStrategy(): Promise<string | null> {
  * @brief 调用额外模型解析，可能会抛出异常。
  */
 export async function generateExtraModel(): Promise<string | null> {
+    let did_set_extra_analysis_states = false;
     try {
-        setExtraAnalysisStates();
+        await setExtraAnalysisStates();
+        did_set_extra_analysis_states = true;
         return await invokeExtraModel();
     } finally {
-        unsetExtraAnalysisStates();
+        if (did_set_extra_analysis_states) {
+            await unsetExtraAnalysisStates();
+        }
     }
 }
 
@@ -245,7 +397,7 @@ function normalizeGenerateResultByResponseFormat(
     result: string | GenerateToolCallResult,
     response_format: string
 ): string {
-    if (response_format === '格式化输出') {
+    if (response_format === '格式化输出' || response_format === V4_COMPATIBLE_FORMATTED_OUTPUT) {
         const formatted = extractFromFormattedOutput(result);
         if (formatted) {
             return formatted;
@@ -257,6 +409,9 @@ function normalizeGenerateResultByResponseFormat(
 async function requestReply(generation_id?: string, batch_id?: string): Promise<string> {
     const store = useDataStore();
     const response_format = store.settings.额外模型解析配置.应答格式;
+    const is_v4_compatible_formatted_output = response_format === V4_COMPATIBLE_FORMATTED_OUTPUT;
+
+    assertV4CompatibleFormattedOutputUsable();
 
     const config: GenerateRawConfig = {
         user_input: '遵循<must>指令',
@@ -280,6 +435,9 @@ async function requestReply(generation_id?: string, batch_id?: string): Promise<
             top_p: unset_if_equal(store.settings.额外模型解析配置.top_p, 1),
             top_k: unset_if_equal(store.settings.额外模型解析配置.top_k, 0),
         };
+        if (is_v4_compatible_formatted_output) {
+            config.custom_api.source = 'custom';
+        }
     }
 
     let task = decoded_extra_model_task;
@@ -292,6 +450,10 @@ async function requestReply(generation_id?: string, batch_id?: string): Promise<
         task +=
             '\n You are in formatted-output mode. Do not output <UpdateVariable> tags, markdown, or prose. Return only a JSON object matching the provided json_schema: {"analysis":"...","json_patch":[...]}. Put MVU JsonPatch dialect operations in `json_patch`.';
         config.json_schema = MVU_JSON_PATCH_RESPONSE_SCHEMA;
+    } else if (is_v4_compatible_formatted_output) {
+        task +=
+            '\n You are in formatted-output mode. Do not output <UpdateVariable> tags, markdown, or prose. Return only a JSON object: {"analysis":"...","json_patch":[...]}. Put MVU JsonPatch dialect operations in `json_patch`. Return exactly one JSON object that conforms to this schema:' +
+            JSON.stringify(MVU_JSON_PATCH_RESPONSE_SCHEMA.value);
     }
 
     //因为部分预设会用到 {{lastUserMessage}}，因此进行修正。

diff --git a/src/panel/update/Prompt.vue b/src/panel/update/Prompt.vue
@@ -29,6 +29,18 @@
             />
         </Field>
 
+        <Field
+            v-if="store.settings.额外模型解析配置.应答格式 === '格式化输出(v4兼容)'"
+            label="关闭thinking"
+        >
+            <template #label-suffix>
+                <HelpIcon help="关闭后会避免一部分空回状况。" />
+            </template>
+            <Checkbox v-model="store.settings.额外模型解析配置.关闭thinking">
+                <span>关闭</span>
+            </Checkbox>
+        </Field>
+
         <Field label="兼容假流式">
             <template #label-suffix>
                 <HelpIcon
@@ -82,8 +94,12 @@ watch(
 );
 
 watch(
-    () => store.settings.额外模型解析配置.应答格式,
-    value => {
+    () =>
+        [
+            store.settings.额外模型解析配置.应答格式,
+            store.settings.额外模型解析配置.模型来源,
+        ] as const,
+    ([value, model_source]) => {
         if (value === '工具调用') {
             const version_message = getFunctionCallingApiVersionUnsupportedMessage();
             if (version_message) {
@@ -105,6 +121,16 @@ watch(
                 return;
             }
         }
+        if (value === '格式化输出(v4兼容)' && model_source === '与插头相同') {
+            toastr.error(
+                '格式化输出(v4兼容)需要额外模型来源为自定义，不能与插头相同',
+                "[MVU]无法使用'格式化输出(v4兼容)'",
+                {
+                    timeOut: 5000,
+                }
+            );
+            store.settings.额外模型解析配置.应答格式 = '聊天消息';
+        }
     }
 );
 </script>
diff --git a/src/panel/update/prompt_toolcall.md b/src/panel/update/prompt_toolcall.md
@@ -7,6 +7,8 @@
   calling。通常能减少正文干扰, 但不支持工具调用的模型或反代会报错或退化。
 - **格式化输出**: 要求提供商支持 OpenAI 兼容的
   `response_format.json_schema`。通常最适合 JsonPatch 变量更新, 因为返回会被约束为结构化 JSON。
+- **格式化输出(v4兼容)**: 用于只支持 `response_format.type = json_object` 的渠道，如 dsv4f 等。
+  这个模式仅在额外模型来源为 **自定义** 时可用。
 
 如果你的渠道明确支持 `response_format.json_schema`, 优先尝试 **格式化输出**。如果不支持, 改用
-**聊天消息**；如果渠道支持 tools/function calling, 也可以尝试 **工具调用**。
+**格式化输出(v4兼容)** 或 **聊天消息**；如果渠道支持 tools/function calling, 也可以尝试 **工具调用**。
diff --git a/src/store.ts b/src/store.ts
@@ -4,7 +4,12 @@ import { defineStore } from 'pinia';
 import { ref, toRaw, watch } from 'vue';
 import * as z from 'zod';
 
-export const EXTRA_MODEL_RESPONSE_FORMATS = ['聊天消息', '工具调用', '格式化输出'] as const;
+export const EXTRA_MODEL_RESPONSE_FORMATS = [
+    '聊天消息',
+    '工具调用',
+    '格式化输出',
+    '格式化输出(v4兼容)',
+] as const;
 
 const ExtraModelResponseFormat = z.enum(EXTRA_MODEL_RESPONSE_FORMATS);
 
@@ -92,6 +97,7 @@ const NewSettings = z
                 其他预设名称: z.string().default(''),
                 使用函数调用: z.boolean().optional(),
                 应答格式: ExtraModelResponseFormat.optional(),
+                关闭thinking: z.boolean().default(false),
                 兼容假流式: z.boolean().default(false),
 
                 启用自动请求: z.boolean().default(true),