refactor: 解耦 Provider Adapter 继承关系

问题：AgnesAdapter extends DeepSeekAdapter 在架构上不合理。
DeepSeek、Agnes AI、Ollama 是三个完全不同的 API，不应有继承关系。

重构：
  BaseAdapter
  ├── DeepSeekAdapter  (独立)
  ├── AgnesAdapter     (独立)
  └── OllamaAdapter    (独立)

变更：
- 新增 shared/openai-format.ts — 提取 OpenAI 兼容消息/工具格式构建
- 新增 shared/sse-stream.ts   — 提取 SSE 流式解析逻辑
- DeepSeekAdapter  重写为独立继承 BaseAdapter，使用共享工具
- AgnesAdapter     重写为独立继承 BaseAdapter，使用共享工具
- OllamaAdapter    无需变更（原本就独立继承）
- adapters/index.ts 清理导出，移除隐式耦合

electron/harness/adapters/agnes-ai.adapter.ts

@@ -1,48 +1,136 @@
 /**
  * Agnes AI Provider Adapter
  *
- * OpenAI 兼容 API，免费使用。
- * 支持 Tool Calling、Thinking 模式、512K 上下文、多模态（图片 base64）。
+ * OpenAI 兼容 API。支持 Tool Calling、Thinking 模式、多模态（图片）。
  *
- * 差异于 DeepSeek：
+ * 独立继承 BaseAdapter，通过 shared/openai-format 和 shared/sse-stream 复用
+ * OpenAI 兼容格式构建和 SSE 流式解析逻辑。不与其他 Provider Adapter 耦合。
+ *
+ * 与 DeepSeek 的差异：
  * - Thinking 模式使用 chat_template_kwargs（非 thinking 字段）
- * - 图片使用 base64 格式（与 Ollama 一致，通过 images 字段传递）
- * - 512K 上下文，65.5K 最大输出
+ * - 默认 max_tokens 更大（65536 vs 8192）
  *
  * @see apis/agnes-ai-api-docs-20260625.html
  */
 
-import { DeepSeekAdapter } from './deepseek.adapter';
-import type { MetonaRequest } from '../types';
+import { BaseAdapter } from './base-adapter';
+import type { MetonaRequest, MetonaResponse, MetonaStreamEvent } from '../types';
+import { MetonaFinishReason } from '../types';
+import { buildOpenAICompatibleMessages, buildOpenAICompatibleTools } from './shared/openai-format';
+import { parseSSEStream, parseOpenAICompatibleResponse } from './shared/sse-stream';
 
-export class AgnesAdapter extends DeepSeekAdapter {
+export class AgnesAdapter extends BaseAdapter {
   override readonly provider: string = 'agnes';
   readonly supportedModels = ['agnes-2.0-flash'];
   readonly supportsToolCalling = true;
   readonly supportsThinking = true;
 
+  // ===== POST /chat/completions (非流式) =====
+
+  async chat(request: MetonaRequest): Promise<MetonaResponse> {
+    const body = this.toNativeRequest(request, false);
+
+    const response = await fetch(`${this.config.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.config.apiKey}`,
+        ...this.config.headers,
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.config.timeoutMs ?? 300_000),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => '');
+      throw new Error(`Agnes AI API error: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+
+    const data = await response.json() as Record<string, unknown>;
+    const parsed = parseOpenAICompatibleResponse(data, request.meta.requestId, this.provider, this.config.defaultModel);
+
+    return {
+      meta: {
+        requestId: request.meta.requestId,
+        provider: this.provider,
+        model: (data.model as string) ?? this.config.defaultModel,
+        latencyMs: 0,
+        timestamp: Date.now(),
+      },
+      content: parsed.content,
+      reasoningContent: parsed.reasoningContent,
+      toolCalls: parsed.toolCalls,
+      usage: parsed.usage,
+      finishReason: parsed.finishReason as MetonaFinishReason,
+    };
+  }
+
+  // ===== POST /chat/completions (流式) =====
+
+  async *chatStream(request: MetonaRequest): AsyncIterable<MetonaStreamEvent> {
+    const body = this.toNativeRequest(request, true);
+
+    const response = await fetch(`${this.config.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.config.apiKey}`,
+        ...this.config.headers,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok || !response.body) {
+      throw new Error(`Agnes AI stream error: ${response.status}`);
+    }
+
+    yield* parseSSEStream(
+      response.body,
+      request.meta.requestId,
+      request.meta.sessionId,
+      request.meta.iteration,
+    );
+  }
+
+  // ========== 私有方法 ==========
+
   /**
-   * 覆盖原生请求构建
+   * 构建 Agnes AI 原生请求体
    *
-   * 差异：
-   * 1. Thinking 模式使用 chat_template_kwargs
-   * 2. 图片处理由基类 DeepSeekAdapter.toNativeRequest 完成（OpenAI 多模态格式）
+   * Agnes AI 特有参数：
+   * - chat_template_kwargs: { enable_thinking: true } — 启用思考模式（非 thinking 字段）
+   * - 默认 max_tokens: 65536（512K 上下文）
    */
-  protected override toNativeRequest(request: MetonaRequest): Record<string, unknown> {
-    const base = super.toNativeRequest(request) as Record<string, unknown>;
+  private toNativeRequest(request: MetonaRequest, stream: boolean): Record<string, unknown> {
+    const messages = buildOpenAICompatibleMessages(request);
+    const tools = buildOpenAICompatibleTools(request.tools);
 
-    // Agnes Thinking 模式：使用 chat_template_kwargs
-    if (request.params?.thinkingEnabled) {
-      delete base.thinking;
-      delete base.reasoning_effort;
-      base.chat_template_kwargs = { enable_thinking: true };
+    const body: Record<string, unknown> = {
+      model: this.config.defaultModel,
+      messages,
+      temperature: request.params.temperature ?? 0,
+      max_tokens: request.params.maxTokens ?? 65536,
+      stream,
+    };
+
+    if (stream) {
+      body.stream_options = { include_usage: true };
     }
 
-    // Agnes 默认 max_tokens 更大
-    if (!request.params.maxTokens) {
-      base.max_tokens = 65536;
+    if (tools) {
+      body.tools = tools;
     }
 
-    return base;
+    // Thinking 模式：Agnes 使用 chat_template_kwargs 而非 thinking
+    if (request.params.thinkingEnabled) {
+      body.chat_template_kwargs = { enable_thinking: true };
+    }
+
+    // 停止序列
+    if (request.params.stopSequences?.length) {
+      body.stop = request.params.stopSequences;
+    }
+
+    return body;
   }
 }