feat: 重构对话功能

electron/gateway/handlers/chat.ts

@@ -0,0 +1,170 @@
+import { randomUUID } from 'crypto';
+import { createProvider } from '@electron/providers';
+import type { BaseProvider } from '@electron/providers/BaseProvider';
+import { providerApiService } from '@electron/service/provider-api-service';
+import logManager from '@electron/service/logger';
+import type { RawMessage } from '@src/pages/home/model/ChatModel';
+import { sessionStore } from '../session-store';
+import type { GatewayEvent, GatewayRpcParams, GatewayRpcReturns } from '../types';
+
+export interface GatewayChatMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string;
+}
+
+function buildChatMessages(sessionMessages: RawMessage[]): GatewayChatMessage[] {
+  return sessionMessages
+    .map((msg): GatewayChatMessage | null => {
+      if (!msg.role || !msg.content) return null;
+      const role = msg.role;
+      if (role === 'user' || role === 'assistant' || role === 'system') {
+        return {
+          role,
+          content: typeof msg.content === 'string' ? msg.content : '',
+        };
+      }
+      // Skip toolresult and unsupported roles for now
+      return null;
+    })
+    .filter((m): m is GatewayChatMessage => m !== null);
+}
+
+async function processChatStream(
+  sessionKey: string,
+  runId: string,
+  provider: BaseProvider,
+  model: string,
+  messages: GatewayChatMessage[],
+  signal: AbortSignal,
+  broadcast: (event: GatewayEvent) => void
+) {
+  let assistantContent = '';
+
+  try {
+    const chunks = await provider.chat(messages, model, { signal });
+
+    for await (const chunk of chunks) {
+      if (signal.aborted) break;
+
+      if (chunk.result) {
+        assistantContent += chunk.result;
+        broadcast({
+          type: 'chat:delta',
+          sessionKey,
+          runId,
+          delta: chunk.result,
+        });
+      }
+
+      if (chunk.isEnd) {
+        break;
+      }
+    }
+
+    if (!signal.aborted) {
+      const finalMessage: RawMessage = {
+        role: 'assistant',
+        content: assistantContent,
+        timestamp: Date.now(),
+      };
+      sessionStore.appendMessage(sessionKey, finalMessage);
+      sessionStore.clearActiveRun(sessionKey);
+
+      broadcast({
+        type: 'chat:final',
+        sessionKey,
+        runId,
+        message: finalMessage,
+      });
+    }
+  } catch (error) {
+    sessionStore.clearActiveRun(sessionKey);
+    broadcast({
+      type: 'chat:error',
+      sessionKey,
+      runId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
+export function handleChatSend(
+  params: GatewayRpcParams['chat.send'],
+  broadcast: (event: GatewayEvent) => void
+): GatewayRpcReturns['chat.send'] {
+  const { sessionKey, message, options } = params;
+  const runId = randomUUID();
+
+  // 1. Append user message
+  sessionStore.appendMessage(sessionKey, {
+    ...message,
+    timestamp: message.timestamp || Date.now(),
+  });
+
+  // 2. Resolve provider account
+  const accountId = options?.providerAccountId || providerApiService.getDefault().accountId;
+  if (!accountId) {
+    throw new Error('No provider account selected');
+  }
+
+  const account = providerApiService.getAccounts().find((a) => a.id === accountId);
+  if (!account) {
+    throw new Error(`Provider account ${accountId} not found`);
+  }
+
+  const model = account.model;
+  if (!model) {
+    throw new Error(`Provider account ${accountId} has no model configured`);
+  }
+
+  // 3. Build messages array from session history
+  const session = sessionStore.getOrCreate(sessionKey);
+  const messages = buildChatMessages(session.messages);
+
+  // 4. Start streaming
+  const abortController = new AbortController();
+  sessionStore.setActiveRun(sessionKey, runId, abortController);
+
+  // Run async stream processing in background
+  const provider = createProvider(accountId);
+  processChatStream(sessionKey, runId, provider, model, messages, abortController.signal, broadcast).catch(
+    (err) => {
+      logManager.error('Unexpected error in processChatStream:', err);
+      sessionStore.clearActiveRun(sessionKey);
+      broadcast({
+        type: 'chat:error',
+        sessionKey,
+        runId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  );
+
+  return { runId };
+}
+
+export function handleChatHistory(
+  params: GatewayRpcParams['chat.history']
+): GatewayRpcReturns['chat.history'] {
+  return sessionStore.getMessages(params.sessionKey, params.limit ?? 50);
+}
+
+export function handleChatAbort(
+  params: GatewayRpcParams['chat.abort'],
+  broadcast: (event: GatewayEvent) => void
+): GatewayRpcReturns['chat.abort'] {
+  const activeRun = sessionStore.getActiveRun(params.sessionKey);
+  if (activeRun) {
+    activeRun.abortController.abort();
+    sessionStore.clearActiveRun(params.sessionKey);
+    broadcast({
+      type: 'chat:aborted',
+      sessionKey: params.sessionKey,
+      runId: activeRun.runId,
+    });
+  }
+}
+
+export function handleSessionList(): GatewayRpcReturns['session.list'] {
+  return sessionStore.getAllKeys();
+}

electron/gateway/handlers/provider.ts

@@ -0,0 +1,13 @@
+import { providerApiService } from '@electron/service/provider-api-service';
+import type { GatewayRpcReturns } from '../types';
+
+export function handleProviderList(): GatewayRpcReturns['provider.list'] {
+  return {
+    accounts: providerApiService.getAccounts(),
+    defaultAccountId: providerApiService.getDefault().accountId,
+  };
+}
+
+export function handleProviderGetDefault(): GatewayRpcReturns['provider.getDefault'] {
+  return providerApiService.getDefault();
+}

electron/gateway/manager.ts

@@ -0,0 +1,59 @@
+import { BrowserWindow } from 'electron';
+import { windowManager } from '@electron/service/window-service';
+import logManager from '@electron/service/logger';
+import type { GatewayEvent } from './types';
+import * as chatHandlers from './handlers/chat';
+import * as providerHandlers from './handlers/provider';
+
+class GatewayManager {
+  private initialized = false;
+
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    this.initialized = true;
+    logManager.info('GatewayManager initialized');
+    this.broadcast({ type: 'gateway:status', status: 'connected' });
+  }
+
+  async rpc(method: string, params: any): Promise<any> {
+    if (!this.initialized) {
+      await this.init();
+    }
+
+    logManager.info(`Gateway RPC: ${method}`, params);
+
+    switch (method) {
+      case 'chat.send':
+        return chatHandlers.handleChatSend(params, (event) => this.broadcast(event));
+      case 'chat.history':
+        return chatHandlers.handleChatHistory(params);
+      case 'chat.abort':
+        return chatHandlers.handleChatAbort(params, (event) => this.broadcast(event));
+      case 'session.list':
+        return chatHandlers.handleSessionList();
+      case 'provider.list':
+        return providerHandlers.handleProviderList();
+      case 'provider.getDefault':
+        return providerHandlers.handleProviderGetDefault();
+      default:
+        throw new Error(`Unknown gateway RPC method: ${method}`);
+    }
+  }
+
+  broadcast(event: GatewayEvent): void {
+    const mainWindow = BrowserWindow.getAllWindows().find(
+      (win) => windowManager.getName(win) === 'main'
+    );
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      mainWindow.webContents.send('gateway:event', event);
+    }
+  }
+
+  reloadProviders(): void {
+    logManager.info('GatewayManager reloading providers');
+    // For now, providers are resolved on each chat.send call,
+    // so no in-memory cache to invalidate. Future: notify active sessions.
+  }
+}
+
+export const gatewayManager = new GatewayManager();

electron/gateway/session-store.ts

@@ -0,0 +1,133 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { app } from 'electron';
+import logManager from '@electron/service/logger';
+import type { RawMessage } from '@src/pages/home/model/ChatModel';
+
+let sessionsFilePath: string | null = null;
+
+function getSessionsFilePath(): string {
+  if (!sessionsFilePath) {
+    sessionsFilePath = path.join(app.getPath('userData'), 'chat-sessions.json');
+  }
+  return sessionsFilePath;
+}
+
+export interface SessionEntry {
+  key: string;
+  messages: RawMessage[];
+  updatedAt: number;
+  activeRun?: {
+    runId: string;
+    abortController: AbortController;
+  };
+}
+
+class SessionStore {
+  private sessions = new Map<string, SessionEntry>();
+  private loaded = false;
+
+  private ensureLoaded(): void {
+    if (this.loaded) return;
+    this.loaded = true;
+    this.loadFromDisk();
+  }
+
+  private loadFromDisk(): void {
+    try {
+      const filePath = getSessionsFilePath();
+      if (fs.existsSync(filePath)) {
+        const data = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as Record<
+          string,
+          Omit<SessionEntry, 'activeRun'>
+        >;
+        for (const [key, entry] of Object.entries(data)) {
+          this.sessions.set(key, {
+            ...entry,
+            activeRun: undefined,
+          });
+        }
+      }
+    } catch (e) {
+      logManager.error('Failed to load sessions from disk:', e);
+    }
+  }
+
+  saveToDisk(): void {
+    try {
+      const filePath = getSessionsFilePath();
+      const data: Record<string, Omit<SessionEntry, 'activeRun'>> = {};
+      for (const [key, entry] of this.sessions) {
+        data[key] = {
+          key: entry.key,
+          messages: entry.messages,
+          updatedAt: entry.updatedAt,
+        };
+      }
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+    } catch (e) {
+      logManager.error('Failed to save sessions to disk:', e);
+    }
+  }
+
+  getOrCreate(key: string): SessionEntry {
+    this.ensureLoaded();
+    let session = this.sessions.get(key);
+    if (!session) {
+      session = {
+        key,
+        messages: [],
+        updatedAt: Date.now(),
+      };
+      this.sessions.set(key, session);
+    }
+    return session;
+  }
+
+  get(key: string): SessionEntry | undefined {
+    this.ensureLoaded();
+    return this.sessions.get(key);
+  }
+
+  getAllKeys(): string[] {
+    this.ensureLoaded();
+    return Array.from(this.sessions.keys());
+  }
+
+  appendMessage(key: string, message: RawMessage): void {
+    const session = this.getOrCreate(key);
+    session.messages.push(message);
+    session.updatedAt = Date.now();
+    this.saveToDisk();
+  }
+
+  getMessages(key: string, limit = 50): RawMessage[] {
+    const session = this.get(key);
+    if (!session) return [];
+    return session.messages.slice(-limit);
+  }
+
+  setActiveRun(key: string, runId: string, abortController: AbortController): void {
+    const session = this.getOrCreate(key);
+    session.activeRun = { runId, abortController };
+  }
+
+  clearActiveRun(key: string): void {
+    const session = this.sessions.get(key);
+    if (session) {
+      session.activeRun = undefined;
+    }
+  }
+
+  getActiveRun(key: string): { runId: string; abortController: AbortController } | undefined {
+    return this.sessions.get(key)?.activeRun;
+  }
+
+  deleteSession(key: string): void {
+    this.sessions.delete(key);
+    this.saveToDisk();
+  }
+}
+
+export const sessionStore = new SessionStore();

electron/gateway/types.ts

@@ -0,0 +1,62 @@
+import type { RawMessage } from '@src/pages/home/model/ChatModel';
+
+/// Gateway 向 Renderer 推送的事件类型
+export type GatewayEvent =
+  | {
+      type: 'chat:delta';
+      sessionKey: string;
+      runId: string;
+      delta: string;
+    }
+  | {
+      type: 'chat:final';
+      sessionKey: string;
+      runId: string;
+      message: RawMessage;
+    }
+  | {
+      type: 'chat:error';
+      sessionKey: string;
+      runId: string;
+      error: string;
+    }
+  | {
+      type: 'chat:aborted';
+      sessionKey: string;
+      runId: string;
+    }
+  | {
+      type: 'gateway:status';
+      status: 'connected' | 'disconnected' | 'reconnecting';
+    };
+
+/// Gateway RPC 方法参数映射
+export interface GatewayRpcParams {
+  'chat.send': {
+    sessionKey: string;
+    message: RawMessage;
+    options?: {
+      providerAccountId?: string;
+    };
+  };
+  'chat.history': {
+    sessionKey: string;
+    limit?: number;
+  };
+  'chat.abort': {
+    sessionKey: string;
+  };
+  'session.list': Record<string, never>;
+  'provider.list': Record<string, never>;
+  'provider.getDefault': Record<string, never>;
+}
+
+/// Gateway RPC 方法返回值映射
+export interface GatewayRpcReturns {
+  'chat.send': { runId: string };
+  'chat.history': RawMessage[];
+  'chat.abort': void;
+  'session.list': string[];
+  'provider.list': { accounts: any[]; defaultAccountId: string | null };
+  'provider.getDefault': { accountId: string | null };
+}