feat: v0.8.1 记忆深化 · 观测闭环 · 体验收口 — 窗口/输出上限全局单一配置 · 2478 用例全量回归 + E2E 冒烟

硬性契约：删除代码中一切写死的上下文窗口与最大输出上限（含六家模型元信息钳制与全部兜底值）——唯一合法来源是设置面板「上下文长度」（llm.contextWindow）与「最大输出上限」（llm.maxTokens），跨 Provider/模型原样透传。 P0 正确性收口： - 迁移 11/12（SCHEMA_VERSION 5）：记忆表 embedding 列 + 分 Provider 窗口键清理 - 记忆生命周期接线：会话终态清理 working memory / episodic 90 天 TTL / access_count 回写 - 回放缓冲模块化 + 会话终态清理（杜绝 4MB/会话内存滞留） - i18n 收口：主进程 main-locale（zh/en，ui.locale 热切换）+ 渲染层 17 处出层 P1 能力演进： - 本地向量混合检索：0.6×向量余弦 + 0.4×TF-IDF，Ollama embeddings 首次投产，存量记忆惰性回填，嵌入不可用自动回退 TF-IDF - MEMORY.md 维护闭环：固化去重消除截断盲区；两阶段维护（AI 建议 → 用户确认 → 原子改写 + 语义记忆双轨同步 + 审计）；>50KB 告警 - 可观测闭环：cacheTokens 引擎→前端透传（Token 面板命中率/成本行）+ 输入框上下文占用指示条 - MCP Prompts/Resources 对话可用：/mcp:{server}:{prompt} 与 @mcp:{server}:{uri} P2 体验补全： - 工具自定义策略（正则白/黑名单 + 频率 + 强制确认，热生效） - 连续 ≥3 同类工具确认聚合为单弹框 - 会话消息游标分页（首屏 200 条向上翻页） - 开机自启；Playwright + Electron E2E 冒烟（本地 mock LLM 零外联） Review 回归修复：MCP 大小写失配 / 分页状态复位 / 清空=未配置语义（Number(null)=0 隐患）/ MEMORY.md 告警位置 / working_memories FK（迁移 13）/ 全局配置层废键清理；附带根治权限加固启动时序、代理回环放行、safeStorage 降级、悬空 symlink 逃逸。验证：typecheck/lint 0 问题；test:electron 2478/2478（0 跳过）；E2E 2/2； docs/v0.8.1-迭代实施清单.md 全项留档。
2026-09-08 09:35:58 +08:00
parent 839860083f
commit 9b45c445bf
85 changed files with 5286 additions and 1158 deletions
@@ -950,11 +950,12 @@ describe('AnthropicAdapter — getContextWindow / listModels', () => {
    expect(adapter.getContextWindow()).toBe(50_000);
  });

-  it('未知模型 → 兜底 200K', () => {
-    expect(makeAdapter('claude-unknown').getContextWindow()).toBe(200_000);
+  // v0.8.1: 窗口唯一来源是设置面板 llm.contextWindow，未配置返回 0（无写死兜底）
+  it('未知模型且未配置 → 返回 0（无写死兜底窗口）', () => {
+    expect(makeAdapter('claude-unknown').getContextWindow()).toBe(0);
  });

-  it('listModels 返回本地模型元信息（无网络请求）', async () => {
+  it('listModels 返回本地模型元信息（无网络请求，不含窗口/上限数值）', async () => {
    const adapter = makeAdapter();
    const models = await adapter.listModels();
    expect(models.map((m) => m.id)).toEqual([
@@ -962,7 +963,10 @@ describe('AnthropicAdapter — getContextWindow / listModels', () => {
      'claude-opus-4-1',
      'claude-haiku-4-5',
    ]);
-    expect(models[0]).toMatchObject({ contextWindow: 200_000, maxOutputTokens: 64_000 });
+    // v0.8.1 硬性契约: 元信息不再承载 contextWindow / maxOutputTokens
+    expect(models[0]).toMatchObject({ supportsThinking: true });
+    expect(models[0].contextWindow).toBeUndefined();
+    expect(models[0].maxOutputTokens).toBeUndefined();
    expect(mockFetch).not.toHaveBeenCalled();
  });
 });
@@ -130,10 +130,11 @@ describe('BaseAdapter — getContextWindow', () => {
    expect(adapter.getContextWindow()).toBe(128_000);
  });

-  // v0.7.4 P4-5: 兜底从 1M 降至 128K（未知模型按最保守主流窗口预算，防 413）
-  it('未配置时返回兜底默认值 128K（子类应覆盖真实窗口）', () => {
+  // v0.8.1 硬性契约: 上下文窗口唯一来源是设置面板 llm.contextWindow，
+  // 未配置返回 0（引擎据此跳过压缩预算）—— 任何写死兜底值均已删除
+  it('未配置时返回 0（无任何写死兜底窗口，引擎跳过压缩判定）', () => {
    const adapter = makeAdapter();
-    expect(adapter.getContextWindow()).toBe(128_000);
+    expect(adapter.getContextWindow()).toBe(0);
  });
 });

@@ -443,15 +444,15 @@ describe('BaseAdapter — throwHttpError 错误体解析', () => {

 // ===== 追加：getContextWindow / listModels / healthCheck =====

-describe('BaseAdapter — getContextWindow 回退链', () => {
-  it('contextWindow=0 视为未配置（需 >0）', () => {
+describe('BaseAdapter — getContextWindow 非法值契约', () => {
+  it('contextWindow=0 视为未配置（返回 0，引擎跳过压缩判定）', () => {
    const adapter = makeAdapter({ contextWindow: 0 });
-    expect(adapter.getContextWindow()).toBe(128_000);
+    expect(adapter.getContextWindow()).toBe(0);
  });

-  it('contextWindow 为负数视为未配置', () => {
+  it('contextWindow 为负数视为未配置（返回 0）', () => {
    const adapter = makeAdapter({ contextWindow: -1 });
-    expect(adapter.getContextWindow()).toBe(128_000);
+    expect(adapter.getContextWindow()).toBe(0);
  });
 });

@@ -104,7 +104,7 @@ describe('DeepSeek vision 模型多模态请求格式（v0.5.4）', () => {
    expect(userMsg.content).toBe('这张图片里有什么？');
  });

-  it('vision 模型 max_tokens 钳制到 8192（MODEL_INFO 上限）', async () => {
+  it('vision 模型 max_tokens 原样透传（v0.8.1：8192 钳制已废除）', async () => {
    mockFetch.mockResolvedValue(okResponse());
    const adapter = makeAdapter('deepseek-v4-flash-vision-exp');

@@ -114,7 +114,7 @@ describe('DeepSeek vision 模型多模态请求格式（v0.5.4）', () => {
    } as MetonaRequest);

    const body = JSON.parse((mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string);
-    expect(body.max_tokens).toBe(8_192);
+    expect(body.max_tokens).toBe(63_488);
  });

  it('vision 模型无图片时不转换（content 保持纯文本）', async () => {
@@ -215,7 +215,7 @@ describe('DeepSeek vision 模型多模态请求格式（v0.5.4）', () => {
    });
  });

-  it('vision 模型 max_tokens 未配置 → 默认 8192（MODEL_INFO 上限）', async () => {
+  it('vision 模型 max_tokens 未配置 → 不下发该字段（v0.8.1：无写死兜底）', async () => {
    mockFetch.mockResolvedValue(okResponse());
    const adapter = makeAdapter('deepseek-v4-flash-vision-exp');

@@ -225,7 +225,7 @@ describe('DeepSeek vision 模型多模态请求格式（v0.5.4）', () => {
    } as MetonaRequest);

    const body = requestBody();
-    expect(body.max_tokens).toBe(8_192);
+    expect(body.max_tokens).toBeUndefined();
  });

  it('vision 模型 thinking 参数显式映射（thinkingEnabled 兼容）', async () => {
@@ -1,10 +1,10 @@
 /**
- * Provider maxTokens 上限钳制契约测试（v0.5.3）
+ * maxTokens 透传契约测试（v0.8.1 硬性契约重写）
 *
- * 背景：引擎默认 maxTokens=63488（engine.ts DEFAULT_CONFIG），超过部分模型
- * 上限时 API 直接 400 —— OpenAI gpt-4o(16384)/gpt-4.1(32768)、Anthropic
- * opus/haiku(32000)、MiMo standard(32768) 曾不可用。v0.5.3 各 adapter 按
- * MODEL_INFO.maxOutputTokens 钳制。
+ * 背景：v0.5.3 曾引入"按 MODEL_INFO.maxOutputTokens 钳制"逻辑。v0.8.1 按硬性
+ * 契约废除 —— 设置面板「最大输出上限」（llm.maxTokens）是唯一合法的输出上限
+ * 配置，adapter 对一切 Provider/模型**原样透传** `params.maxTokens`，代码中
+ * 不存在任何写死的输出上限或按模型元信息的钳制行为。
 *
 * 测试策略（v0.5.2 教训）：mock fetch 记录真实请求体并断言契约 ——
 * 不 mock adapter 内部方法，验证"发出的 HTTP 请求体"这个最终事实。
@@ -33,7 +33,7 @@ afterEach(() => {
  mockFetch.mockReset();
 });

-/** 引擎默认形态的请求（maxTokens=63488，与 engine DEFAULT_CONFIG 一致） */
+/** 设置面板「最大输出上限」配置生效时的请求形态（llm.maxTokens → params.maxTokens） */
 function makeRequest(overrides: Partial<MetonaRequest> = {}): MetonaRequest {
  return {
    meta: {
@@ -79,8 +79,8 @@ function requestBody(): Record<string, unknown> {
  return JSON.parse(init.body as string) as Record<string, unknown>;
 }

-describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
-  it('DeepSeek v4 pro（上限 384K）：63488 未超限，原样传递', async () => {
+describe('maxTokens 原样透传（v0.8.1：设置面板是唯一合法上限配置）', () => {
+  it('DeepSeek：max_tokens 原样透传（不按模型钳制）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new DeepSeekAdapter({
      provider: 'deepseek',
@@ -92,7 +92,19 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
    expect(requestBody().max_tokens).toBe(63_488);
  });

-  it('Agnes flash（上限 65536）：63488 未超限，原样传递', async () => {
+  it('DeepSeek：超出旧模型元信息上限的值同样原样透传（钳制已废除）', async () => {
+    mockFetch.mockResolvedValue(openAIResponse());
+    const adapter = new DeepSeekAdapter({
+      provider: 'deepseek',
+      baseURL: 'https://api.deepseek.com',
+      apiKey: 'sk',
+      defaultModel: 'deepseek-v4-flash-vision-exp',
+    });
+    await adapter.send(makeRequest());
+    expect(requestBody().max_tokens).toBe(63_488);
+  });
+
+  it('Agnes：max_tokens 原样透传', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new AgnesAdapter({
      provider: 'agnes',
@@ -104,7 +116,7 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
    expect(requestBody().max_tokens).toBe(63_488);
  });

-  it('MiMo standard（上限 32768）：钳制到 32768（原为 400 错误场景）', async () => {
+  it('MiMo standard：max_completion_tokens 原样透传（旧 32768 钳制已废除）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new MimoAdapter({
      provider: 'mimo',
@@ -113,10 +125,10 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
      defaultModel: 'mimo-v2.5',
    });
    await adapter.send(makeRequest());
-    expect(requestBody().max_completion_tokens).toBe(32_768);
+    expect(requestBody().max_completion_tokens).toBe(63_488);
  });

-  it('MiMo pro（上限 131072）：63488 未超限，原样传递', async () => {
+  it('MiMo pro：max_completion_tokens 原样透传', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new MimoAdapter({
      provider: 'mimo',
@@ -128,7 +140,7 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
    expect(requestBody().max_completion_tokens).toBe(63_488);
  });

-  it('OpenAI gpt-4o（上限 16384）：钳制到 16384（原为 400 错误场景）', async () => {
+  it('OpenAI gpt-4o（非推理模型）：max_tokens 原样透传（旧 16384 钳制已废除）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new OpenAIAdapter({
      provider: 'openai',
@@ -137,10 +149,10 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
      defaultModel: 'gpt-4o',
    });
    await adapter.send(makeRequest());
-    expect(requestBody().max_tokens).toBe(16_384);
+    expect(requestBody().max_tokens).toBe(63_488);
  });

-  it('OpenAI o3-mini（上限 100K）：63488 未超限，推理模型字段名正确', async () => {
+  it('OpenAI o3-mini（推理模型）：max_completion_tokens 原样透传，字段名路由正确', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new OpenAIAdapter({
      provider: 'openai',
@@ -153,7 +165,7 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
    expect(requestBody().max_tokens).toBeUndefined();
  });

-  it('Anthropic opus（上限 32000）：钳制到 32000（原为 400 错误场景）', async () => {
+  it('Anthropic opus：max_tokens 原样透传（旧 32000 钳制已废除）', async () => {
    mockFetch.mockResolvedValue(anthropicResponse());
    const adapter = new AnthropicAdapter({
      provider: 'anthropic',
@@ -162,10 +174,10 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
      defaultModel: 'claude-opus-4-1',
    });
    await adapter.send(makeRequest());
-    expect(requestBody().max_tokens).toBe(32_000);
+    expect(requestBody().max_tokens).toBe(63_488);
  });

-  it('Anthropic sonnet（上限 64000）：63488 未超限', async () => {
+  it('Anthropic sonnet：max_tokens 原样透传', async () => {
    mockFetch.mockResolvedValue(anthropicResponse());
    const adapter = new AnthropicAdapter({
      provider: 'anthropic',
@@ -177,13 +189,12 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
    expect(requestBody().max_tokens).toBe(63_488);
  });

-  it('未配置 maxTokens 时各 adapter 使用安全默认值（不超过模型上限）', async () => {
+  it('未配置 maxTokens：不下发任何输出上限字段（由 Provider 服务端默认值决定）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const request = makeRequest({
      params: { temperature: 0, stream: false } as MetonaRequest['params'],
    });

-    // MiMo standard + thinking 默认 → 兜底 32768（= 上限，安全）
    const mimo = new MimoAdapter({
      provider: 'mimo',
      baseURL: 'https://api.mimo.com/v1',
@@ -191,6 +202,33 @@ describe('maxTokens 模型上限钳制（引擎默认 63488 场景）', () => {
      defaultModel: 'mimo-v2.5',
    });
    await mimo.send(request);
-    expect(requestBody().max_completion_tokens).toBe(32_768);
+    expect(requestBody().max_completion_tokens).toBeUndefined();
+
+    const deepseek = new DeepSeekAdapter({
+      provider: 'deepseek',
+      baseURL: 'https://api.deepseek.com',
+      apiKey: 'sk',
+      defaultModel: 'deepseek-v4-pro',
+    });
+    mockFetch.mockReset();
+    mockFetch.mockResolvedValue(openAIResponse());
+    await deepseek.send(request);
+    expect(requestBody().max_tokens).toBeUndefined();
+  });
+
+  it('Anthropic 未配置 maxTokens + thinking 开启：仅满足协议下限 2048（协议不变量，非上限）', async () => {
+    mockFetch.mockResolvedValue(anthropicResponse());
+    const adapter = new AnthropicAdapter({
+      provider: 'anthropic',
+      baseURL: 'https://api.anthropic.com',
+      apiKey: 'k',
+      defaultModel: 'claude-opus-4-1',
+    });
+    await adapter.send(
+      makeRequest({
+        params: { temperature: 0, stream: false, thinkingEnabled: true } as MetonaRequest['params'],
+      }),
+    );
+    expect(requestBody().max_tokens).toBe(2048);
  });
 });
@@ -452,13 +452,25 @@ describe('OllamaAdapter — 能力探测', () => {
    expect(caps).toEqual({ supportsTools: true, supportsVision: true, supportsThinking: true });
  });

-  it('capabilities 为空数组（showModel 缺省 []）→ 三能力全 false（非 null）', async () => {
+  // v0.8.1: showModel 保留 undefined 语义 —— 响应缺 capabilities 字段 = 未知 → null
+  //（fail-open），不再把"字段缺失"与"权威空"混同（探测竞态下曾误判不支持思考）
+  it('capabilities 字段缺失 → 返回 null（未知，fail-open）', async () => {
    const adapter = makeAdapter();
    mockFetch.mockResolvedValue({
      ok: true,
      status: 200,
      json: async () => ({ parameters: '', template: '' }),
    } as unknown as Response);
+    expect(await adapter.probeCapabilities('qwen3')).toBeNull();
+  });
+
+  it('capabilities 为显式空数组（服务端权威无能力）→ 三能力全 false', async () => {
+    const adapter = makeAdapter();
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ parameters: '', template: '', capabilities: [] }),
+    } as unknown as Response);
    expect(await adapter.probeCapabilities('qwen3')).toEqual({
      supportsTools: false,
      supportsVision: false,
@@ -688,28 +700,33 @@ describe('OllamaAdapter — 图片归一化', () => {

 // ===== getContextWindow =====

-describe('OllamaAdapter — getContextWindow', () => {
-  it('未探测到时返回默认 4096', () => {
+describe('OllamaAdapter — getContextWindow（v0.8.1：唯一来源是设置面板配置）', () => {
+  it('未配置 contextWindow → 返回 0（无 4096 写死兜底，引擎跳过压缩判定）', () => {
    const adapter = makeAdapter();
-    expect(adapter.getContextWindow()).toBe(4096);
+    expect(adapter.getContextWindow()).toBe(0);
  });

-  it('探测到 num_ctx 后返回实测值（机会主义缓存收敛）', async () => {
-    // 需在构造前就位：构造时的 fire-and-forget 探测消费首个 fetch
+  it('config.contextWindow（llm.contextWindow 注入）→ 返回配置值', () => {
+    const adapter = makeAdapter('qwen3', { contextWindow: 32_768 });
+    expect(adapter.getContextWindow()).toBe(32_768);
+  });
+
+  it('/api/show 探测不再缓存窗口数值（num_ctx 由引擎 contextLength 下发）', async () => {
    mockFetch.mockResolvedValue({
      ok: true,
      status: 200,
      json: async () => ({ parameters: 'num_ctx 32768', template: '', capabilities: [] }),
    } as unknown as Response);
    const adapter = makeAdapter();
-    // 等待构造时的探测完成并写入缓存
-    await vi.waitFor(() => expect(adapter.getContextWindow()).toBe(32768));
+    // 探测完成（含失败路径）后窗口仍为 0 —— 探测只服务于能力门控
+    await new Promise((r) => setTimeout(r, 20));
+    expect(adapter.getContextWindow()).toBe(0);
  });

-  it('探测失败（网络错误）→ 保持默认 4096', async () => {
+  it('探测失败（网络错误）→ 仍返回配置值/0，不抛错不阻塞', async () => {
    mockFetch.mockRejectedValue(new Error('down'));
    const adapter = makeAdapter();
    await new Promise((r) => setTimeout(r, 20));
-    expect(adapter.getContextWindow()).toBe(4096);
+    expect(adapter.getContextWindow()).toBe(0);
  });
 });
@@ -205,12 +205,12 @@ describe('OpenAIAdapter — 推理模型拒图（ModelCapabilityError）', () =>

 // ===== max_completion_tokens / max_tokens 路由 =====

-describe('OpenAIAdapter — token 参数路由', () => {
+describe('OpenAIAdapter — token 参数路由（v0.8.1：原样透传，无模型钳制）', () => {
  it.each([
    ['o3-mini', 63_488, 63_488, 'max_completion_tokens'],
-    ['o3-mini', 200_000, 100_000, 'max_completion_tokens'], // 上限 100000
-    ['gpt-4o', 63_488, 16_384, 'max_tokens'],
-    ['gpt-4.1', 63_488, 32_768, 'max_tokens'],
+    ['o3-mini', 200_000, 200_000, 'max_completion_tokens'], // 超过任何旧元信息上限 → 原样
+    ['gpt-4o', 63_488, 63_488, 'max_tokens'],
+    ['gpt-4.1', 63_488, 63_488, 'max_tokens'],
  ] as const)('%s maxTokens=%d → %s=%d', async (model, requested, expected, field) => {
    const adapter = makeAdapter(model);
    mockFetch.mockResolvedValue(okResponse());
@@ -224,18 +224,18 @@ describe('OpenAIAdapter — token 参数路由', () => {
    expect(body[other]).toBeUndefined();
  });

-  it('o3-mini 未配置 maxTokens → 默认 32768（thinking 场景安全值）', async () => {
+  it('o3-mini 未配置 maxTokens → 不下发 max_completion_tokens（无写死兜底）', async () => {
    const adapter = makeAdapter('o3-mini');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(makeRequest({ params: { temperature: 0, stream: false } }));
-    expect(lastBody().max_completion_tokens).toBe(32_768);
+    expect(lastBody().max_completion_tokens).toBeUndefined();
  });

-  it('非推理模型未配置 maxTokens → 默认模型上限', async () => {
+  it('非推理模型未配置 maxTokens → 不下发 max_tokens（无写死兜底）', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(makeRequest({ params: { temperature: 0, stream: false } }));
-    expect(lastBody().max_tokens).toBe(16_384);
+    expect(lastBody().max_tokens).toBeUndefined();
  });
 });

@@ -277,23 +277,17 @@ describe('OpenAIAdapter — temperature 路由', () => {

 // ===== getContextWindow 回退链 =====

-describe('OpenAIAdapter — getContextWindow 回退链', () => {
-  it('gpt-4.1 返回 1M 上下文', () => {
-    expect(makeAdapter('gpt-4.1').getContextWindow()).toBe(1_000_000);
-  });
-
-  it('o3-mini 返回 200K', () => {
-    expect(makeAdapter('o3-mini').getContextWindow()).toBe(200_000);
-  });
-
-  it('未知模型 → 兜底 128K（v0.7.4 P4-5 从 1M 降级）', () => {
-    expect(makeAdapter('unknown-model-x').getContextWindow()).toBe(128_000);
-  });
-
-  it('config.contextWindow 显式配置优先', () => {
+describe('OpenAIAdapter — getContextWindow（v0.8.1：唯一来源是设置面板配置）', () => {
+  it('config.contextWindow 显式配置（llm.contextWindow 注入）返回配置值', () => {
    const adapter = makeAdapter('gpt-4o', { contextWindow: 64_000 });
    expect(adapter.getContextWindow()).toBe(64_000);
  });
+
+  it('未配置（任意模型，含已知/未知）→ 返回 0（引擎跳过压缩判定，无写死兜底）', () => {
+    expect(makeAdapter('gpt-4.1').getContextWindow()).toBe(0);
+    expect(makeAdapter('o3-mini').getContextWindow()).toBe(0);
+    expect(makeAdapter('unknown-model-x').getContextWindow()).toBe(0);
+  });
 });

 // ===== listModels =====
@@ -303,7 +297,9 @@ describe('OpenAIAdapter — listModels 动态发现与降级', () => {
    mockFetch.mockResolvedValue(okResponse({ data: [{ id: 'gpt-4o' }, { id: 'custom-model' }] }));
    const models = await makeAdapter('gpt-4o').listModels();
    expect(models).toHaveLength(2);
-    expect(models[0]).toMatchObject({ id: 'gpt-4o', contextWindow: 128_000 });
+    // v0.8.1: 元信息不再承载窗口/上限数值
+    expect(models[0]).toMatchObject({ id: 'gpt-4o', name: 'GPT-4o' });
+    expect(models[0].contextWindow).toBeUndefined();
    expect(models[1]).toEqual({ id: 'custom-model' });
    // /models 请求头携带 Bearer
    const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
@@ -178,7 +178,7 @@ describe('AnthropicAdapter — 请求体契约', () => {
    expect(toolResultBlocks[0].tool_use_id).toBe('tc_1');
  });

-  it('A2: max_tokens 按模型上限钳制（63488 → sonnet 64000 / opus 32000）', async () => {
+  it('A2: max_tokens 原样透传（v0.8.1：模型钳制已废除，设置面板是唯一上限来源）', async () => {
    const sonnet = new AnthropicAdapter({
      provider: 'anthropic',
      baseURL: 'http://a.test',
@@ -194,9 +194,9 @@ describe('AnthropicAdapter — 请求体契约', () => {
    const { bodies } = captureFetch();
    await sonnet.send(makeRequest());
    await opus.send(makeRequest());
-    // 引擎默认 63488 低于 sonnet 上限 64000 → 原样保留；opus 上限 32000 → 钳制生效
+    // v0.8.1: 设置面板「最大输出上限」对一切模型原样透传，无任何按模型钳制
    expect(bodies[0].max_tokens).toBe(63_488);
-    expect(bodies[1].max_tokens).toBe(32_000);
+    expect(bodies[1].max_tokens).toBe(63_488);
  });

  it('A3: 小 maxTokens 时 thinking budget 不跌破协议下限 1024（v0.6.4 边界加固）', async () => {
@@ -516,8 +516,8 @@ describe('AnthropicAdapter — thinking budget 按 effort 映射矩阵', () => {
    ['low', 1024],
    ['medium', 4096],
    ['high', 16384],
-    // max=32768 但 sonnet 的 max_tokens 先钳到 64000 → budget 二次钳到 floor(64000/2)=32000
-    ['max', 32000],
+    // v0.8.1: max_tokens 不再按模型钳制（100_000 原样透传）→ budget = min(32768, floor(100000/2)) = 32768
+    ['max', 32768],
  ] as const)('effort=%s → budget 为该档值且 < max_tokens', async (effort, expectBudget) => {
    const adapter = makeAdapter();
    const { bodies } = captureFetch();
@@ -570,13 +570,13 @@ describe('AnthropicAdapter — thinking budget 按 effort 映射矩阵', () => {
  });
 });

-describe('AnthropicAdapter — max_tokens 钳制矩阵', () => {
+describe('AnthropicAdapter — max_tokens 透传矩阵（v0.8.1 无钳制）', () => {
  it.each([
-    ['claude-sonnet-4-5', 63_488, 63_488], // 引擎默认低于上限 → 原样
-    ['claude-sonnet-4-5', 70_000, 64_000], // 超上限 → 钳到 sonnet 64000
-    ['claude-opus-4-1', 63_488, 32_000], // opus 上限 32000
-    ['claude-haiku-4-5', 63_488, 32_000], // haiku 上限 32000
-    ['claude-sonnet-4-5', 500, 500], // 低于上限 → 原样
+    ['claude-sonnet-4-5', 63_488, 63_488],
+    ['claude-sonnet-4-5', 70_000, 70_000], // 超过任何旧元信息上限 → 原样透传
+    ['claude-opus-4-1', 63_488, 63_488],
+    ['claude-haiku-4-5', 63_488, 63_488],
+    ['claude-sonnet-4-5', 500, 500],
  ])('%s maxTokens=%d → max_tokens=%d', async (model, requested, expected) => {
    const adapter = new AnthropicAdapter({
      provider: 'anthropic',
@@ -795,7 +795,7 @@ describe('DeepSeekAdapter — thinking 映射矩阵', () => {
    expect(bodies[0].stop).toEqual(['<END>']);
  });

-  it('max_tokens 按模型钳制（pro 384000 / vision 8192）', async () => {
+  it('max_tokens 原样透传（v0.8.1：pro/vision 均不钳制）', async () => {
    const pro = makeAdapter('deepseek-v4-pro');
    const vision = makeAdapter('deepseek-v4-flash-vision-exp');
    const { bodies } = captureFetch();
@@ -803,8 +803,8 @@ describe('DeepSeekAdapter — thinking 映射矩阵', () => {
    await vision.send(
      makeRequest({ params: { maxTokens: 63_488, temperature: 0, stream: false } }),
    );
-    expect(bodies[0].max_tokens).toBe(384_000);
-    expect(bodies[1].max_tokens).toBe(8_192);
+    expect(bodies[0].max_tokens).toBe(500_000);
+    expect(bodies[1].max_tokens).toBe(63_488);
  });
 });

@@ -864,8 +864,8 @@ describe('AgnesAdapter — enable_thinking 对称性矩阵', () => {
      makeRequest({ params: { maxTokens: 70_000, temperature: 0.9, stream: false } }),
    );
    expect(bodies[0].temperature).toBe(0.9);
-    // 65536 上限钳制
-    expect(bodies[0].max_tokens).toBe(65_536);
+    // v0.8.1: 原样透传，无 65536 钳制
+    expect(bodies[0].max_tokens).toBe(70_000);
  });
 });

@@ -912,21 +912,21 @@ describe('MimoAdapter — thinking 显式开关', () => {
    expect(bodies[0].top_p).toBeUndefined();
  });

-  it('max_completion_tokens 钳制矩阵（pro 131072 / standard 32768）', async () => {
+  it('max_completion_tokens 原样透传（v0.8.1：pro/standard 均不钳制）', async () => {
    const pro = makeAdapter({ defaultModel: 'mimo-v2.5-pro' });
    const std = makeAdapter({ defaultModel: 'mimo-v2.5' });
    const { bodies } = captureFetch();
    await pro.send(makeRequest({ params: { maxTokens: 200_000, temperature: 0, stream: false } }));
    await std.send(makeRequest({ params: { maxTokens: 63_488, temperature: 0, stream: false } }));
-    expect(bodies[0].max_completion_tokens).toBe(131_072);
-    expect(bodies[1].max_completion_tokens).toBe(32_768);
+    expect(bodies[0].max_completion_tokens).toBe(200_000);
+    expect(bodies[1].max_completion_tokens).toBe(63_488);
  });

-  it('thinking 未关闭时未配置 maxTokens → 兜底 32768（思考占配额，防截断）', async () => {
+  it('thinking 未关闭时未配置 maxTokens → 不下发该字段（v0.8.1：无写死兜底值）', async () => {
    const pro = makeAdapter({ defaultModel: 'mimo-v2.5-pro' });
    const { bodies } = captureFetch();
    await pro.send(makeRequest({ params: { temperature: 0, stream: false } }));
-    expect(bodies[0].max_completion_tokens).toBe(32_768);
+    expect(bodies[0].max_completion_tokens).toBeUndefined();
  });

  it('enableWebSearch 且存在客户端 tools → web_search 服务端工具追加（不覆盖客户端工具）', async () => {
@@ -1029,27 +1029,36 @@ describe('OpenAIAdapter — 推理模型字段路由（v0.6.4 P3-1）', () => {
    expect(bodies[0].reasoning_effort).toBeUndefined();
  });

-  it('gpt-4.1 长上下文 1M → getContextWindow 返回 1M（模型元信息表）', () => {
-    const adapter = makeAdapter('gpt-4.1');
+  it('gpt-4.1 → getContextWindow 返回设置面板配置值（v0.8.1：元信息不再承载窗口）', () => {
+    const adapter = new OpenAIAdapter({
+      provider: 'openai',
+      baseURL: 'http://o.test',
+      apiKey: 'k',
+      defaultModel: 'gpt-4.1',
+      contextWindow: 1_000_000,
+    });
    expect(adapter.getContextWindow()).toBe(1_000_000);
+    // 未配置 → 0（引擎跳过压缩判定），无任何写死兜底
+    const noCfg = makeAdapter('gpt-4.1');
+    expect(noCfg.getContextWindow()).toBe(0);
  });

-  it('o3-mini max_completion_tokens 钳制到 100000', async () => {
+  it('o3-mini max_completion_tokens 原样透传（v0.8.1：无 100000 钳制）', async () => {
    const adapter = makeAdapter('o3-mini');
    const { bodies } = captureFetch();
    await adapter.send(
      makeRequest({ params: { maxTokens: 200_000, temperature: 0, stream: false } }),
    );
-    expect(bodies[0].max_completion_tokens).toBe(100_000);
+    expect(bodies[0].max_completion_tokens).toBe(200_000);
  });

-  it('gpt-4o max_tokens 钳制到 16384', async () => {
+  it('gpt-4o max_tokens 原样透传（v0.8.1：无 16384 钳制）', async () => {
    const adapter = makeAdapter('gpt-4o');
    const { bodies } = captureFetch();
    await adapter.send(
      makeRequest({ params: { maxTokens: 63_488, temperature: 0, stream: false } }),
    );
-    expect(bodies[0].max_tokens).toBe(16_384);
+    expect(bodies[0].max_tokens).toBe(63_488);
  });
 });

@@ -1255,16 +1264,16 @@ describe('OllamaAdapter — options 缺省与工具定义', () => {

 // ===== 跨 Provider maxTokens 钳制矩阵 =====

-describe('跨 Provider — maxTokens 钳制矩阵汇总', () => {
+describe('跨 Provider — maxTokens 透传矩阵汇总（v0.8.1 无钳制）', () => {
  it.each([
-    ['anthropic', 'claude-opus-4-1', 100_000, 32_000],
-    ['anthropic', 'claude-sonnet-4-5', 100_000, 64_000],
-    ['deepseek', 'deepseek-v4-flash-vision-exp', 100_000, 8_192],
-    ['agnes', 'agnes-2.0-flash', 100_000, 65_536],
-    ['mimo', 'mimo-v2.5', 100_000, 32_768],
-    ['openai', 'gpt-4o', 100_000, 16_384],
+    ['anthropic', 'claude-opus-4-1', 100_000, 100_000],
+    ['anthropic', 'claude-sonnet-4-5', 100_000, 100_000],
+    ['deepseek', 'deepseek-v4-flash-vision-exp', 100_000, 100_000],
+    ['agnes', 'agnes-2.0-flash', 100_000, 100_000],
+    ['mimo', 'mimo-v2.5', 100_000, 100_000],
+    ['openai', 'gpt-4o', 100_000, 100_000],
  ] as const)(
-    '%s %s maxTokens=100000 → 钳制为 %d',
+    '%s %s maxTokens=100000 → 原样透传 %d',
    async (provider, model, requested, expected) => {
      const adapterMap: Record<string, unknown> = {
        anthropic: new AnthropicAdapter({
@@ -56,7 +56,7 @@ function asNative(
 }

 describe('P0-3 修订: 用户思考意图优先于模型元信息', () => {
-  it('DeepSeek: vision-exp（元信息 false）+ 用户开启思考 → 照发 enabled + reasoning_effort，max_tokens 仍按模型钳制 8192', async () => {
+  it('DeepSeek: vision-exp（元信息 false）+ 用户开启思考 → 照发 enabled + reasoning_effort，max_tokens 原样透传（v0.8.1 无钳制）', async () => {
    const adapter = new DeepSeekAdapter({
      provider: 'deepseek',
      baseURL: 'https://api.deepseek.com',
@@ -66,7 +66,7 @@ describe('P0-3 修订: 用户思考意图优先于模型元信息', () => {
    const body = asNative(adapter)(makeRequest(), false);
    expect(body.thinking).toEqual({ type: 'enabled' });
    expect(body.reasoning_effort).toBe('max');
-    expect(body.max_tokens).toBe(8192);
+    expect(body.max_tokens).toBe(63488);
  });

  it('DeepSeek: 用户关闭思考 → 显式 disabled', async () => {
@@ -23,16 +23,15 @@ export class AgnesAdapter extends OpenAICompatibleAdapter {
  readonly supportsToolCalling = true;
  readonly supportsThinking = true;

-  // H-2 修复: Agnes 模型元信息（1M 上下文，65.5K 最大输出）
+  // H-2 修复: Agnes 模型元信息（v0.8.1: 仅承载展示与能力声明 —— 窗口/输出上限
+  // 数值已按硬性契约删除，唯一合法来源是设置面板 llm.contextWindow / llm.maxTokens）
  private static readonly MODEL_INFO: Record<string, MetonaModelInfo> = {
    'agnes-2.0-flash': {
      id: 'agnes-2.0-flash',
      name: 'Agnes 2.0 Flash',
-      contextWindow: 1_000_000,
-      maxOutputTokens: 65_536,
      supportsToolCalling: true,
      supportsThinking: true,
-      description: 'Agnes AI 快速版，1M 上下文，支持多模态图片（URL + Base64）与思考模式',
+      description: 'Agnes AI 快速版，支持多模态图片（URL + Base64）与思考模式',
    },
  };

@@ -72,16 +71,13 @@ export class AgnesAdapter extends OpenAICompatibleAdapter {
      );
    }

-    // v0.5.3: max_tokens 按模型上限钳制（agnes-2.0-flash 上限 65536）
-    const modelInfo = AgnesAdapter.MODEL_INFO[this.config.defaultModel];
-    const maxOutput = modelInfo?.maxOutputTokens ?? 65_536;
-    const maxTokens = Math.min(request.params.maxTokens ?? maxOutput, maxOutput);
-
+    // v0.8.1 硬性契约: max_tokens 原样透传设置面板「最大输出上限」（llm.maxTokens），
+    // 删除了旧的按模型元信息钳制逻辑
    const body: Record<string, unknown> = {
      model: this.config.defaultModel,
      messages,
      temperature: request.params.temperature,
-      max_tokens: maxTokens,
+      max_tokens: request.params.maxTokens,
      stream,
    };

@@ -52,21 +52,19 @@ export class AnthropicAdapter extends BaseAdapter {
  readonly supportsToolCalling = true;
  readonly supportsThinking = true;

+  // v0.8.1: 仅承载展示与能力声明 —— 窗口/输出上限数值已按硬性契约删除，
+  // 唯一合法来源是设置面板 llm.contextWindow / llm.maxTokens
  private static readonly MODEL_INFO: Record<string, MetonaModelInfo> = {
    'claude-sonnet-4-5': {
      id: 'claude-sonnet-4-5',
      name: 'Claude Sonnet 4.5',
-      contextWindow: 200_000,
-      maxOutputTokens: 64_000,
      supportsToolCalling: true,
      supportsThinking: true,
-      description: 'Anthropic 旗舰模型，200K 上下文，支持扩展思考与工具调用',
+      description: 'Anthropic 旗舰模型，支持扩展思考与工具调用',
    },
    'claude-opus-4-1': {
      id: 'claude-opus-4-1',
      name: 'Claude Opus 4.1',
-      contextWindow: 200_000,
-      maxOutputTokens: 32_000,
      supportsToolCalling: true,
      supportsThinking: true,
      description: 'Anthropic 深度推理模型',
@@ -74,8 +72,6 @@ export class AnthropicAdapter extends BaseAdapter {
    'claude-haiku-4-5': {
      id: 'claude-haiku-4-5',
      name: 'Claude Haiku 4.5',
-      contextWindow: 200_000,
-      maxOutputTokens: 32_000,
      supportsToolCalling: true,
      supportsThinking: true,
      description: 'Anthropic 低延迟模型',
@@ -416,13 +412,9 @@ export class AnthropicAdapter extends BaseAdapter {
    return this.supportedModels.map((id) => AnthropicAdapter.MODEL_INFO[id] ?? { id });
  }

-  override getContextWindow(): number {
-    if (typeof this.config.contextWindow === 'number' && this.config.contextWindow > 0) {
-      return this.config.contextWindow;
-    }
-    const modelInfo = AnthropicAdapter.MODEL_INFO[this.config.defaultModel];
-    return modelInfo?.contextWindow ?? 200_000;
-  }
+  // getContextWindow 使用基类实现 —— v0.8.1 硬性契约：唯一来源是
+  // 设置面板「上下文长度」（llm.contextWindow → AdapterConfig.contextWindow），
+  // 未配置返回 0，引擎据此跳过压缩预算计算。

  // ========== 私有方法 ==========

@@ -531,22 +523,21 @@ export class AnthropicAdapter extends BaseAdapter {
      });
    }

-    // v0.5.3: max_tokens 按模型上限钳制（sonnet 64000 / opus 32000 / haiku 32000）—
-    // 引擎默认 63488 超过 opus/haiku 上限时 API 直接 400；thinking budget 已在此值内二分
-    const anthropicMaxOutput =
-      AnthropicAdapter.MODEL_INFO[this.config.defaultModel]?.maxOutputTokens ?? 64_000;
-
-    // v0.6.4 边界加固: thinking 开启时保证 max_tokens ≥ 2048 —— 协议要求
-    // budget_tokens >= 1024 且 < max_tokens。原实现当用户配置极小 maxTokens
-    // （如 1500）时 Math.floor(1500/2)=750 < 1024 直接 API 400。
-    const requestedMaxTokens = request.params.maxTokens ?? 8192;
+    // v0.8.1 硬性契约: max_tokens 原样透传设置面板「最大输出上限」（llm.maxTokens），
+    // 删除了旧的按模型元信息钳制逻辑（MODEL_INFO.maxOutputTokens 已删除）。
+    // 唯一保留的协议不变量：thinking 开启时 max_tokens ≥ 2048 —— Anthropic 协议
+    // 要求 budget_tokens >= 1024 且 < max_tokens，用户配置低于该下限时 API 必然
+    // 400，此为协议正确性下限而非输出上限（不修改用户配置的持久化值，仅在
+    // 本次请求体上满足协议约束）。
+    const requestedMaxTokens = request.params.maxTokens;
    const maxTokensForRequest = thinkingRequested
-      ? Math.max(2048, Math.min(requestedMaxTokens, anthropicMaxOutput))
-      : Math.min(requestedMaxTokens, anthropicMaxOutput);
+      ? Math.max(2048, requestedMaxTokens ?? 2048)
+      : requestedMaxTokens;

    const body: Record<string, unknown> = {
      model: this.config.defaultModel,
-      max_tokens: maxTokensForRequest,
+      // v0.8.1: 未配置「最大输出上限」时不下发 max_tokens（服务端默认值生效）
+      ...(maxTokensForRequest != null ? { max_tokens: maxTokensForRequest } : {}),
      messages: merged,
      stream,
    };
@@ -581,7 +572,8 @@ export class AnthropicAdapter extends BaseAdapter {
        max: 32768,
      };
      const effortBudget = budgetMap[request.params.thinkingEffort ?? 'high'] ?? 16384;
-      const budget = Math.min(effortBudget, Math.floor(maxTokensForRequest / 2));
+      // thinking 路径 maxTokensForRequest 恒为数字（Math.max(2048, …) 兜底）
+      const budget = Math.min(effortBudget, Math.floor((maxTokensForRequest ?? 2048) / 2));
      body.thinking = { type: 'enabled', budget_tokens: budget };
    } else {
      body.temperature = request.params.temperature;
@@ -69,19 +69,15 @@ export abstract class BaseAdapter implements IMetonaProviderAdapter {
  /**
   * H-2 修复: 获取上下文窗口大小（规范要求）
   *
-   * 默认实现从 config 读取 contextWindow，子类可覆盖以支持动态查询。
-   * Engine 用此值估算上下文使用率，决定是否触发压缩。
-   *
-   * @returns 上下文窗口大小（token 数）
+   * v0.8.1 硬性契约：上下文窗口的唯一合法来源是设置面板 LLM 配置的「上下文长度」
+   * （llm.contextWindow，经 main.ts 注入 AdapterConfig.contextWindow）。
+   * 本基类与所有子类禁止携带任何写死的默认窗口值 —— 未配置时返回 0，
+   * 引擎据此跳过压缩预算计算（syncContextWindow 仅在 >0 时采纳）。
   */
  getContextWindow(): number {
-    // 优先使用 AdapterConfig.contextWindow（如果存在）
    const ctx = (this.config as AdapterConfig & { contextWindow?: number }).contextWindow;
    if (typeof ctx === 'number' && ctx > 0) return ctx;
-    // v0.7.4 P4-5: 兜底从 1M 降至 128K —— 旧默认值 1M 在 config 与模型元信息均缺失时
-    // （如 DeepSeek 未知模型），压缩阈值按 1M 算，实际 64K/128K 模型会先 413 再压缩。
-    // 128K 是当前最保守的主流窗口，未知模型按最小值预算更安全。
-    return 128_000;
+    return 0;
  }

  /**
@@ -28,32 +28,27 @@ export class DeepSeekAdapter extends OpenAICompatibleAdapter {
  readonly supportsToolCalling = true;
  readonly supportsThinking = true;

-  // H-2 修复: DeepSeek 模型元信息（1M 上下文，384K 最大输出）
+  // H-2 修复: DeepSeek 模型元信息（v0.8.1: 仅承载展示与能力声明 —— 窗口/输出上限
+  // 数值已按硬性契约删除，唯一合法来源是设置面板 llm.contextWindow / llm.maxTokens）
  private static readonly MODEL_INFO: Record<string, MetonaModelInfo> = {
    'deepseek-v4-pro': {
      id: 'deepseek-v4-pro',
      name: 'DeepSeek V4 Pro',
-      contextWindow: 1_000_000,
-      maxOutputTokens: 384_000,
      supportsToolCalling: true,
      supportsThinking: true,
-      description: 'DeepSeek 旗舰模型，1M 上下文，支持深度推理与工具调用',
+      description: 'DeepSeek 旗舰模型，支持深度推理与工具调用',
    },
    'deepseek-v4-flash': {
      id: 'deepseek-v4-flash',
      name: 'DeepSeek V4 Flash',
-      contextWindow: 1_000_000,
-      maxOutputTokens: 384_000,
      supportsToolCalling: true,
      supportsThinking: true,
-      description: 'DeepSeek 快速版，1M 上下文，低延迟推理',
+      description: 'DeepSeek 快速版，低延迟推理',
    },
    // v0.5.4: DeepSeek 多模态实验模型（OpenAI image_url content parts 格式）
    'deepseek-v4-flash-vision-exp': {
      id: 'deepseek-v4-flash-vision-exp',
      name: 'DeepSeek V4 Flash Vision (Exp)',
-      contextWindow: 128_000,
-      maxOutputTokens: 8_192,
      supportsToolCalling: true,
      supportsThinking: false,
      description: 'DeepSeek 多模态实验模型，支持图片输入（image_url content parts）',
@@ -173,16 +168,13 @@ export class DeepSeekAdapter extends OpenAICompatibleAdapter {
    const messages = buildOpenAICompatibleMessages(request, this.isVisionModel());
    const tools = buildOpenAICompatibleTools(request.tools);

-    // v0.5.3: max_tokens 按模型上限钳制 — 引擎默认 63488 超过部分模型上限时 API 直接 400
-    const modelInfo = DeepSeekAdapter.MODEL_INFO[this.config.defaultModel];
-    const maxOutput = modelInfo?.maxOutputTokens ?? 384_000;
-    const maxTokens = Math.min(request.params.maxTokens ?? maxOutput, maxOutput);
-
+    // v0.8.1 硬性契约: max_tokens 原样透传设置面板「最大输出上限」（llm.maxTokens），
+    // 删除了旧的按模型元信息钳制逻辑 —— 代码中不存在任何写死的输出上限。
    const body: Record<string, unknown> = {
      model: this.config.defaultModel,
      messages,
      temperature: request.params.temperature,
-      max_tokens: maxTokens,
+      max_tokens: request.params.maxTokens,
      stream,
    };

@@ -228,11 +220,11 @@ export class DeepSeekAdapter extends OpenAICompatibleAdapter {
          `[DeepSeek] model "${this.config.defaultModel}" metadata says thinking unsupported — sending thinking params per user config (degraded retry handles budget exhaustion)`,
        );
      }
-      // v0.8.0 P0-3: 思考会占用输出预算 —— 钳制后预算过小时显式告警
+      // v0.8.0 P0-3: 思考会占用输出预算 —— 用户配置的输出预算过小时显式告警
      //（思考 token 计入 max_tokens，预算过小会出现"思考耗尽正文为零"截断）
-      if (maxTokens < 8192) {
+      if (typeof request.params.maxTokens === 'number' && request.params.maxTokens < 8192) {
        log.warn(
-          `[DeepSeek] thinking enabled with small output budget (${maxTokens} tokens after model clamp) — reasoning may consume the entire budget and truncate the answer`,
+          `[DeepSeek] thinking enabled with small output budget (${request.params.maxTokens} tokens per user config) — reasoning may consume the entire budget and truncate the answer`,
        );
      }
    }
@@ -24,13 +24,12 @@ export class MimoAdapter extends OpenAICompatibleAdapter {
  readonly supportsThinking = true;

  // MiMo 模型元信息
-  // mimo-v2.5-pro: 1M 上下文 / 131072 max_tokens；mimo-v2.5: 1M 上下文 / 32768 max_tokens
+  // v0.8.1: 仅承载展示与能力声明 —— 窗口/输出上限数值已按硬性契约删除，
+  // 唯一合法来源是设置面板 llm.contextWindow / llm.maxTokens
  private static readonly MODEL_INFO: Record<string, MetonaModelInfo> = {
    'mimo-v2.5-pro': {
      id: 'mimo-v2.5-pro',
      name: 'MiMo V2.5 Pro',
-      contextWindow: 1_000_000,
-      maxOutputTokens: 131_072,
      supportsToolCalling: true,
      supportsThinking: true,
      description: '小米 MiMo 旗舰模型，支持深度思考与工具调用',
@@ -38,8 +37,6 @@ export class MimoAdapter extends OpenAICompatibleAdapter {
    'mimo-v2.5': {
      id: 'mimo-v2.5',
      name: 'MiMo V2.5',
-      contextWindow: 1_000_000,
-      maxOutputTokens: 32_768,
      supportsToolCalling: true,
      supportsThinking: true,
      description: '小米 MiMo 标准模型，低延迟推理',
@@ -82,17 +79,13 @@ export class MimoAdapter extends OpenAICompatibleAdapter {
    const tools = buildOpenAICompatibleTools(request.tools);

    // MiMo 使用 max_completion_tokens（非 max_tokens）
-    // #41 修复: thinking 模式下未配置时兜底 32768（thinking 占用 token 配额，API 默认值过小会截断输出）
-    // v0.5.3: 按模型上限钳制（pro 131072 / standard 32768）—
-    // 引擎默认 63488 超过 standard 上限时 API 直接 400
-    const mimoMaxOutput =
-      MimoAdapter.MODEL_INFO[this.config.defaultModel]?.maxOutputTokens ?? 131_072;
-    const mimoDefault = request.params.thinkingEnabled !== false ? 32_768 : mimoMaxOutput;
-
+    // v0.8.1 硬性契约: 原样透传设置面板「最大输出上限」（llm.maxTokens），删除了
+    // 旧的"#41 thinking 兜底 32768"与"按模型上限钳制"逻辑 —— 代码中不存在任何
+    // 写死的输出上限；未配置时该字段不下发，由服务端默认值决定。
    const body: Record<string, unknown> = {
      model: this.config.defaultModel,
      messages,
-      max_completion_tokens: Math.min(request.params.maxTokens ?? mimoDefault, mimoMaxOutput),
+      max_completion_tokens: request.params.maxTokens,
      stream,
    };

@@ -145,11 +138,11 @@ export class MimoAdapter extends OpenAICompatibleAdapter {
          `[MiMo] model "${this.config.defaultModel}" metadata says thinking unsupported — sending thinking params per user config (degraded retry handles budget exhaustion)`,
        );
      }
-      // v0.8.0 P0-3: 思考占用输出预算 —— 钳制后预算过小时显式告警
-      const effectiveMax = body.max_completion_tokens as number;
+      // v0.8.0 P0-3: 思考占用输出预算 —— 用户配置的输出预算过小时显式告警
+      const effectiveMax = body.max_completion_tokens as number | undefined;
      if (typeof effectiveMax === 'number' && effectiveMax < 8192) {
        log.warn(
-          `[MiMo] thinking enabled with small output budget (${effectiveMax} tokens after model clamp) — reasoning may consume the entire budget and truncate the answer`,
+          `[MiMo] thinking enabled with small output budget (${effectiveMax} tokens per user config) — reasoning may consume the entire budget and truncate the answer`,
        );
      }
    }
@@ -37,18 +37,48 @@ export class OllamaAdapter extends BaseAdapter {
  readonly supportsToolCalling = true;
  readonly supportsThinking = true;

-  // H-2 修复: Ollama 本地模型默认上下文窗口（可由 options.num_ctx 覆盖）
-  private static readonly DEFAULT_CONTEXT_WINDOW = 4096;
-
  private baseURL: string;

  constructor(config: ConstructorParameters<typeof BaseAdapter>[0]) {
    super(config);
    this.baseURL = config.baseURL || 'http://localhost:11434';
-    // v0.6.4 P4-1: 每个适配器实例（= 每会话独立引擎）启动时做一次 /api/show 探测，
-    // 把 num_ctx 实测值填充进 getContextWindow 缓存。fire-and-forget：失败静默，
-    // 不阻塞/不影响首个请求；此后压缩预算基于实测窗口而非保守默认 4096。
-    this.refreshContextWindow();
+    // v0.8.1: 上下文窗口不再从 /api/show 探测或写死默认值获取 —— 唯一合法来源是
+    // 设置面板「上下文长度」（llm.contextWindow → AdapterConfig.contextWindow，
+    // 引擎侧经 contextLength=num_ctx 下发）。构造时仅探测能力（thinking/tools/vision，
+    // 属协议正确性门控），不再缓存窗口数值。
+    this.probeCapabilitiesOnce();
+  }
+
+  /** /api/show 能力探测只发一次（构造函数发起），失败不重试（fail-open） */
+  private probeAttempted = false;
+  private probeInProgress = false;
+  /**
+   * /api/show capabilities 探测缓存 —— 模型是否支持思考（协议正确性门控，
+   * 非窗口/输出上限语义）。null = 未探测/探测失败（fail-open 放行，与
+   * listModels 能力回退策略一致）；false = 服务端明确不支持 → 不发 think 参数。
+   */
+  private cachedThinkingSupport: boolean | null = null;
+
+  /**
+   * v0.8.1: 构造时 fire-and-forget 探测一次默认模型能力（仅 thinking 门控消费）。
+   * 旧实现同时缓存 num_ctx 窗口数值 —— 已按"窗口唯一来源是设置面板"契约删除。
+   */
+  private probeCapabilitiesOnce(): void {
+    if (this.probeAttempted) return;
+    this.probeAttempted = true;
+    this.probeInProgress = true;
+    void this.showModel(this.config.defaultModel)
+      .then((info) => {
+        if (Array.isArray(info?.capabilities)) {
+          this.cachedThinkingSupport = info!.capabilities.map(String).includes('thinking');
+        }
+      })
+      .catch(() => {
+        /* 模型探测失败不阻塞对话（fail-open） */
+      })
+      .finally(() => {
+        this.probeInProgress = false;
+      });
  }

  // ===== POST /api/chat =====
@@ -356,14 +386,13 @@ export class OllamaAdapter extends BaseAdapter {
          // 该模型回退保守 true（不可用时行为与旧实现一致，fail-open 保可用性）
          // v0.7.3 P1-4: supportsVision 随探测结果透出（undefined = 未知 → 前端保守放行），
          // 供上传入口拒绝不支持图片的本地语言模型
+          // v0.8.1: 不再填充 contextWindow —— 窗口唯一来源是设置面板「上下文长度」
          const enriched = await Promise.all(
            data.models.map(async (m) => {
              const caps = await this.probeCapabilities(m.name);
              return {
                id: m.name,
                name: m.name,
-                // Ollama 模型上下文窗口由 options.num_ctx 决定，此处给保守值
-                contextWindow: OllamaAdapter.DEFAULT_CONTEXT_WINDOW,
                supportsToolCalling: caps ? caps.supportsTools : true,
                supportsThinking: caps ? caps.supportsThinking : true,
                supportsVision: caps ? caps.supportsVision : undefined,
@@ -386,59 +415,15 @@ export class OllamaAdapter extends BaseAdapter {
  /**
   * H-2 修复: 获取上下文窗口大小（规范要求）
   *
-   * Ollama 上下文窗口由 options.num_ctx 决定（默认 4096），
-   * Engine 应通过 MetonaRequest.params.contextLength 显式设置。
-   * 此处返回默认值，供 Engine 在未指定时参考。
+   * v0.8.1 硬性契约: 唯一来源是设置面板「上下文长度」（llm.contextWindow），
+   * 未配置返回 0 —— 删除了旧的 4096 写死默认值与 /api/show num_ctx 探测缓存。
+   * Ollama 的 num_ctx 由引擎经 params.contextLength（同源配置）下发给服务端。
   */
  override getContextWindow(): number {
-    return this.cachedContextWindow ?? OllamaAdapter.DEFAULT_CONTEXT_WINDOW;
-  }
-
-  /**
-   * v0.6.4 P4-1: 从 /api/show 的 parameters 区解析 num_ctx 真值。
-   *
-   * 契约约束：IMetonaProviderAdapter.getContextWindow 是同步接口（引擎压缩判定
-   * 依赖同步取值），无法在内部 await。因此采用"机会主义缓存"策略：
-   * send/sendStream 启动时 fire-and-forget 刷新缓存；首次请求前返回默认 4096，
-   * 之后永远返回实测值。压缩预算的准确性随使用逐渐收敛到真值。
-   */
-  private cachedContextWindow: number | null = null;
-  private refreshingContextWindow = false;
-  /** v0.8.0 P0-3: /api/show 探测只发一次（构造函数发起），失败不重试（fail-open） */
-  private probeAttempted = false;
-  /**
-   * v0.8.0 P0-3: /api/show capabilities 探测缓存 —— 模型是否支持思考。
-   * null = 未探测/探测失败（fail-open 放行，与 listModels 能力回退策略一致）；
-   * false = 服务端明确不支持 → toNativeRequest 不发 think 参数。
-   */
-  private cachedThinkingSupport: boolean | null = null;
-
-  private refreshContextWindow(): void {
-    if (this.refreshingContextWindow || this.probeAttempted) return;
-    this.probeAttempted = true;
-    this.refreshingContextWindow = true;
-    void this.showModel(this.config.defaultModel)
-      .then((info) => {
-        if (!info?.parameters) return;
-        const match = /^num_ctx\s+(\d+)\s*$/m.exec(info.parameters);
-        if (match) {
-          const value = Number(match[1]);
-          if (Number.isFinite(value) && value > 0) {
-            this.cachedContextWindow = value;
-            log.info(`[Ollama] Context window (num_ctx) detected: ${value}`);
-          }
-        }
-        // v0.8.0 P0-3: 同一次探测顺带缓存思考能力（供 toNativeRequest 同步门控）
-        if (Array.isArray(info.capabilities)) {
-          this.cachedThinkingSupport = info.capabilities.map(String).includes('thinking');
-        }
-      })
-      .catch(() => {
-        /* 模型探测失败不阻塞对话 */
-      })
-      .finally(() => {
-        this.refreshingContextWindow = false;
-      });
+    if (typeof this.config.contextWindow === 'number' && this.config.contextWindow > 0) {
+      return this.config.contextWindow;
+    }
+    return 0;
  }

  /**
@@ -466,7 +451,7 @@ export class OllamaAdapter extends BaseAdapter {

  async showModel(
    model: string,
-  ): Promise<{ parameters: string; template: string; capabilities: string[] } | null> {
+  ): Promise<{ parameters: string; template: string; capabilities?: string[] } | null> {
    try {
      const response = await fetch(`${this.baseURL}/api/show`, {
        method: 'POST',
@@ -483,7 +468,10 @@ export class OllamaAdapter extends BaseAdapter {
      return {
        parameters: data.parameters ?? '',
        template: data.template ?? '',
-        capabilities: data.capabilities ?? [],
+        // v0.8.1: 保留 undefined 语义 —— 响应未携带 capabilities 字段 = 未知
+        //（fail-open），显式数组（含空数组 = 服务端权威"无任何能力"）才参与门控。
+        // 旧实现 `?? []` 把"字段缺失"与"权威空"混同，探测竞态下会误判不支持思考。
+        capabilities: data.capabilities,
      };
    } catch {
      return null;
@@ -707,7 +695,7 @@ export class OllamaAdapter extends BaseAdapter {
    // think 会导致每次请求 400 "does not support thinking"，而非静默忽略），
    // 故此处门控属协议正确性而非用户意图覆盖；探测为服务端实时真值（非静态
    // 元信息）。未探测/探测失败（null）fail-open 放行，与 listModels 能力回退
-    // 策略一致。探测在适配器实例创建时 fire-and-forget 发起（refreshContextWindow）。
+    // 策略一致。探测在适配器实例创建时 fire-and-forget 发起（probeCapabilitiesOnce）。
    if (request.params.thinkingEnabled) {
      const modelThinkingSupported = this.cachedThinkingSupport !== false;
      if (modelThinkingSupported) {
@@ -24,39 +24,33 @@ export class OpenAIAdapter extends OpenAICompatibleAdapter {
  readonly supportsToolCalling = true;
  readonly supportsThinking = true;

+  // v0.8.1: 仅承载展示与能力声明 —— 窗口/输出上限数值已按硬性契约删除，
+  // 唯一合法来源是设置面板 llm.contextWindow / llm.maxTokens
  private static readonly MODEL_INFO: Record<string, MetonaModelInfo> = {
    'gpt-4o': {
      id: 'gpt-4o',
      name: 'GPT-4o',
-      contextWindow: 128_000,
-      maxOutputTokens: 16_384,
      supportsToolCalling: true,
      supportsThinking: false,
-      description: 'OpenAI 旗舰多模态模型，128K 上下文',
+      description: 'OpenAI 旗舰多模态模型',
    },
    'gpt-4o-mini': {
      id: 'gpt-4o-mini',
      name: 'GPT-4o mini',
-      contextWindow: 128_000,
-      maxOutputTokens: 16_384,
      supportsToolCalling: true,
      supportsThinking: false,
-      description: 'OpenAI 高性价比模型，128K 上下文',
+      description: 'OpenAI 高性价比模型',
    },
    'gpt-4.1': {
      id: 'gpt-4.1',
      name: 'GPT-4.1',
-      contextWindow: 1_000_000,
-      maxOutputTokens: 32_768,
      supportsToolCalling: true,
      supportsThinking: false,
-      description: 'OpenAI 长上下文模型，1M 上下文',
+      description: 'OpenAI 长上下文模型',
    },
    'o3-mini': {
      id: 'o3-mini',
      name: 'o3-mini',
-      contextWindow: 200_000,
-      maxOutputTokens: 100_000,
      supportsToolCalling: true,
      supportsThinking: true,
      description: 'OpenAI 推理模型，支持 reasoning_effort',
@@ -81,11 +75,6 @@ export class OpenAIAdapter extends OpenAICompatibleAdapter {
    return 'OpenAI';
  }

-  // v0.6.4: OpenAI 家族兜底窗口为 128K（其余 OpenAI 兼容 Provider 为 1M）
-  protected override defaultContextWindowFallback(): number {
-    return 128_000;
-  }
-
  // ===== GET /v1/models =====

  override async listModels(): Promise<MetonaModelInfo[]> {
@@ -137,18 +126,13 @@ export class OpenAIAdapter extends OpenAICompatibleAdapter {
    };

    // Token 上限参数：o 系列/gpt-5 使用 max_completion_tokens
-    // v0.5.3: 按模型上限钳制（gpt-4o 16384 / gpt-4.1 32768 / o3-mini 100000）—
-    // 引擎默认 63488 超过 gpt-4o/gpt-4.1 上限时 API 直接 400
-    const oaMaxOutput = OpenAIAdapter.MODEL_INFO[model]?.maxOutputTokens ?? 128_000;
-    const oaMaxTokens = Math.min(
-      request.params.maxTokens ?? (isReasoningModel ? 32_768 : oaMaxOutput),
-      oaMaxOutput,
-    );
-    if (oaMaxTokens) {
+    // v0.8.1 硬性契约: 原样透传设置面板「最大输出上限」（llm.maxTokens），删除了
+    // 旧的按模型元信息钳制逻辑与未配置时的 32_768 兜底 —— 未配置时不下发该字段。
+    if (request.params.maxTokens != null) {
      if (isReasoningModel) {
-        body.max_completion_tokens = oaMaxTokens;
+        body.max_completion_tokens = request.params.maxTokens;
      } else {
-        body.max_tokens = oaMaxTokens;
+        body.max_tokens = request.params.maxTokens;
      }
    }

@@ -169,10 +153,10 @@ export class OpenAIAdapter extends OpenAICompatibleAdapter {
        max: 'high',
      };
      body.reasoning_effort = effortMap[request.params.thinkingEffort ?? 'high'] ?? 'high';
-      // v0.8.0 P0-3: 推理 token 计入 max_completion_tokens —— 钳制后预算过小时告警
-      if (oaMaxTokens < 8192) {
+      // v0.8.0 P0-3: 推理 token 计入 max_completion_tokens —— 用户配置的预算过小时告警
+      if (typeof request.params.maxTokens === 'number' && request.params.maxTokens < 8192) {
        log.warn(
-          `[OpenAI] reasoning enabled with small output budget (${oaMaxTokens} tokens after model clamp) — reasoning may consume the entire budget and truncate the answer`,
+          `[OpenAI] reasoning enabled with small output budget (${request.params.maxTokens} tokens per user config) — reasoning may consume the entire budget and truncate the answer`,
        );
      }
    } else if (!isReasoningModel) {
@@ -41,16 +41,9 @@ export abstract class OpenAICompatibleAdapter extends BaseAdapter {
  /** 非流式 send 的默认超时。DeepSeek/MiMo/OpenAI=120s；Agnes 历史 300s，保留其值。 */
  protected abstract sendTimeoutMs(): number;

-  /** 模型元信息表（子类持有；用于 getContextWindow 回退链与钳制） */
+  /** 模型元信息表（子类持有；仅承载展示与能力声明，不含任何窗口/输出上限数值） */
  protected abstract modelInfoTable(): Record<string, MetonaModelInfo>;

-  /** getContextWindow 的最终兜底窗口（未配置且模型未知时使用） */
-  // v0.7.4 P4-5: 1M → 128K（与 base-adapter 兜底对齐）——未知模型按最保守主流窗口预算，
-  // 防止压缩阈值按 1M 计算导致实际小窗口模型先 413 再压缩
-  protected defaultContextWindowFallback(): number {
-    return 128_000;
-  }
-
  // ===== 认证头 =====

  protected buildHeaders(): Record<string, string> {
@@ -161,15 +154,16 @@ export abstract class OpenAICompatibleAdapter extends BaseAdapter {
  }

  /**
-   * 上下文窗口回退链（v0.6.3 一致化后的统一实现）：
-   * config.contextWindow（用户显式配置）→ 模型元信息 → Provider 兜底。
+   * 上下文窗口（v0.8.1 硬性契约单一化）：
+   * 唯一合法来源是设置面板「上下文长度」（llm.contextWindow → AdapterConfig.contextWindow）。
+   * 删除了旧的 config → 模型元信息 → 兜底 三级回退链 —— 模型元信息不再承载窗口数值，
+   * 未配置时返回 0（引擎据此跳过压缩预算，行为与"用户未声明窗口"语义一致）。
   */
  override getContextWindow(): number {
    if (typeof this.config.contextWindow === 'number' && this.config.contextWindow > 0) {
      return this.config.contextWindow;
    }
-    const modelInfo = this.modelInfoTable()[this.config.defaultModel];
-    return modelInfo?.contextWindow ?? this.defaultContextWindowFallback();
+    return 0;
  }
 }