refactor(core): 提取共享基类和类型，消除重复代码

- 新增 AbstractAdapterRegistry 抽象基类，统一 Text/Image Registry 实现
- 提取共享类型 ConnectionSchema、BaseProvider、BaseModel 到 shared/types.ts
- 重命名 history/errors.ts 中的 StorageError 为 HistoryStorageError 避免命名冲突
- 移除 model/errors.ts 中重复的 ModelConfigError 定义
- 删除 model/defaults.ts 中未使用的 clearModelsCache 函数
- TextAdapterRegistry: 273 → 95 行，ImageAdapterRegistry: 186 → 84 行

Author: linshenkx

packages/core/src/services/adapters/abstract-registry.ts

@@ -0,0 +1,256 @@
+/**
+ * 适配器注册表抽象基类
+ * 提供文本和图像适配器注册表的共享逻辑
+ *
+ * @template TAdapter 适配器类型
+ * @template TProvider Provider 元数据类型
+ * @template TModel Model 元数据类型
+ * @template TConnectionConfig 连接配置类型（用于动态模型获取）
+ */
+export abstract class AbstractAdapterRegistry<
+  TAdapter,
+  TProvider extends { id: string; name: string; supportsDynamicModels: boolean },
+  TModel extends { id: string },
+  TConnectionConfig = Record<string, unknown>
+> {
+  protected adapters: Map<string, TAdapter> = new Map();
+  protected staticModelsCache: Map<string, TModel[]> = new Map();
+
+  constructor() {
+    this.initializeAdapters();
+  }
+
+  /**
+   * 子类必须实现：初始化并注册所有适配器
+   */
+  protected abstract initializeAdapters(): void;
+
+  /**
+   * 子类必须实现：从适配器获取 Provider 元数据
+   */
+  protected abstract getProviderFromAdapter(adapter: TAdapter): TProvider;
+
+  /**
+   * 子类必须实现：从适配器获取静态模型列表
+   */
+  protected abstract getModelsFromAdapter(adapter: TAdapter): TModel[];
+
+  /**
+   * 子类必须实现：调用适配器的异步模型获取方法
+   */
+  protected abstract getModelsAsyncFromAdapter(
+    adapter: TAdapter,
+    connectionConfig: TConnectionConfig
+  ): Promise<TModel[]>;
+
+  /**
+   * 子类可选实现：获取错误消息的提供商类型描述
+   */
+  protected getProviderTypeDescription(): string {
+    return '提供商';
+  }
+
+  /**
+   * 预加载所有 Provider 的静态模型到缓存
+   */
+  protected preloadStaticModels(): void {
+    this.adapters.forEach((adapter, providerId) => {
+      const provider = this.getProviderFromAdapter(adapter);
+      if (provider.id === providerId) {
+        this.staticModelsCache.set(providerId, this.getModelsFromAdapter(adapter));
+      }
+    });
+  }
+
+  // ===== 基础适配器管理 =====
+
+  /**
+   * 通过 providerId 获取适配器实例
+   * @param providerId Provider ID（自动转换为小写）
+   * @returns 适配器实例
+   * @throws {Error} 当 providerId 不存在时
+   */
+  public getAdapter(providerId: string): TAdapter {
+    const adapter = this.adapters.get(providerId.toLowerCase());
+    if (!adapter) {
+      throw new Error(`未知${this.getProviderTypeDescription()}: ${providerId}`);
+    }
+    return adapter;
+  }
+
+  // ===== 元数据查询 =====
+
+  /**
+   * 获取所有已注册的 Provider 元数据
+   * @returns Provider 元数据数组
+   */
+  public getAllProviders(): TProvider[] {
+    const providers: TProvider[] = [];
+    const seenIds = new Set<string>();
+
+    this.adapters.forEach((adapter) => {
+      const provider = this.getProviderFromAdapter(adapter);
+      if (!seenIds.has(provider.id)) {
+        seenIds.add(provider.id);
+        providers.push(provider);
+      }
+    });
+
+    return providers;
+  }
+
+  // ===== 静态模型获取（即时可用） =====
+
+  /**
+   * 获取静态模型列表（带缓存）
+   * @param providerId Provider ID
+   * @returns 静态模型数组
+   */
+  public getStaticModels(providerId: string): TModel[] {
+    const normalizedId = providerId.toLowerCase();
+
+    // 尝试从缓存获取
+    if (this.staticModelsCache.has(normalizedId)) {
+      return this.staticModelsCache.get(normalizedId)!;
+    }
+
+    // 如果缓存未命中，从适配器获取
+    const adapter = this.getAdapter(normalizedId);
+    const models = this.getModelsFromAdapter(adapter);
+    this.staticModelsCache.set(normalizedId, models);
+    return models;
+  }
+
+  // ===== 动态模型获取（需要连接配置） =====
+
+  /**
+   * 动态获取模型列表
+   * @param providerId Provider ID
+   * @param connectionConfig 连接配置
+   * @returns 动态获取的模型数组
+   * @throws {Error} 当 Provider 不支持动态获取时
+   */
+  public async getDynamicModels(
+    providerId: string,
+    connectionConfig: TConnectionConfig
+  ): Promise<TModel[]> {
+    const adapter = this.getAdapter(providerId);
+    const provider = this.getProviderFromAdapter(adapter);
+
+    if (!provider.supportsDynamicModels) {
+      throw new Error(`${provider.name} 不支持动态模型获取`);
+    }
+
+    try {
+      return await this.getModelsAsyncFromAdapter(adapter, connectionConfig);
+    } catch (error) {
+      console.warn(`动态获取模型失败 (${providerId}):`, error);
+      throw error;
+    }
+  }
+
+  // ===== 统一的模型获取接口（自动选择静态或动态） =====
+
+  /**
+   * 统一的模型获取接口
+   * 优先动态获取，失败则 fallback 到静态模型
+   *
+   * @param providerId Provider ID
+   * @param connectionConfig 连接配置（可选，提供时尝试动态获取）
+   * @returns 模型数组
+   */
+  public async getModels(
+    providerId: string,
+    connectionConfig?: TConnectionConfig
+  ): Promise<TModel[]> {
+    const adapter = this.getAdapter(providerId);
+    const provider = this.getProviderFromAdapter(adapter);
+
+    // 如果支持动态获取且提供了连接配置，尝试动态获取
+    if (provider.supportsDynamicModels && connectionConfig) {
+      try {
+        const dynamicModels = await this.getDynamicModels(providerId, connectionConfig);
+
+        // 合并静态和动态模型，动态模型优先
+        const staticModels = this.getStaticModels(providerId);
+        const dynamicIds = new Set(dynamicModels.map((m) => m.id));
+        const mergedModels = [
+          ...dynamicModels,
+          ...staticModels.filter((m) => !dynamicIds.has(m.id))
+        ];
+
+        return mergedModels;
+      } catch (error) {
+        console.warn(
+          `动态模型加载失败 (${providerId})，回退到静态模型:`,
+          error
+        );
+        // 降级到静态模型
+        return this.getStaticModels(providerId);
+      }
+    }
+
+    // 返回静态模型
+    return this.getStaticModels(providerId);
+  }
+
+  /**
+   * 获取所有静态模型的组合视图
+   * @returns Provider-Model 对数组
+   */
+  public getAllStaticModels(): Array<{ provider: TProvider; model: TModel }> {
+    const result: Array<{ provider: TProvider; model: TModel }> = [];
+
+    for (const provider of this.getAllProviders()) {
+      const models = this.getStaticModels(provider.id);
+      for (const model of models) {
+        result.push({ provider, model });
+      }
+    }
+
+    return result;
+  }
+
+  // ===== 能力检查 =====
+
+  /**
+   * 检查 Provider 是否支持动态模型获取
+   * @param providerId Provider ID
+   * @returns 是否支持动态获取
+   */
+  public supportsDynamicModels(providerId: string): boolean {
+    try {
+      const adapter = this.getAdapter(providerId);
+      return this.getProviderFromAdapter(adapter).supportsDynamicModels;
+    } catch {
+      return false;
+    }
+  }
+
+  // ===== 验证方法 =====
+
+  /**
+   * 验证 Provider 和 Model 组合是否有效
+   * @param providerId Provider ID
+   * @param modelId Model ID
+   * @returns 是否有效
+   */
+  public validateProviderModel(providerId: string, modelId: string): boolean {
+    try {
+      const models = this.getStaticModels(providerId);
+      return models.some((model) => model.id === modelId);
+    } catch {
+      return false;
+    }
+  }
+
+  // ===== 辅助方法：清除缓存 =====
+
+  /**
+   * 清除静态模型缓存并重新加载
+   */
+  public clearCache(): void {
+    this.staticModelsCache.clear();
+    this.preloadStaticModels();
+  }
+}

packages/core/src/services/adapters/index.ts

@@ -0,0 +1 @@
+export { AbstractAdapterRegistry } from './abstract-registry';

packages/core/src/services/history/errors.ts

@@ -42,15 +42,17 @@ export class RecordNotFoundError extends HistoryError {
 }
 
 /**
- * 存储错误
+ * 历史记录存储错误
+ * 注意：此类与 storage/errors.ts 中的 StorageError 不同，
+ * 专用于历史记录模块的存储操作错误
  */
-export class StorageError extends HistoryError {
+export class HistoryStorageError extends HistoryError {
   constructor(
     message: string,
     public operation: 'read' | 'write' | 'delete' | 'init' | 'storage'
   ) {
     super(message);
-    this.name = 'StorageError';
+    this.name = 'HistoryStorageError';
   }
 }
 

packages/core/src/services/history/manager.ts

@@ -1,7 +1,7 @@
 import { IHistoryManager, PromptRecord, PromptRecordChain } from './types';
 import { IStorageProvider } from '../storage/types';
 import { StorageAdapter } from '../storage/adapter';
-import { RecordNotFoundError, RecordValidationError, StorageError, HistoryError } from './errors';
+import { RecordNotFoundError, RecordValidationError, HistoryStorageError, HistoryError } from './errors';
 import { v4 as uuidv4 } from 'uuid';
 import { IModelManager } from '../model/types';
 import { CORE_SERVICE_KEYS } from '../../constants/storage-keys';
@@ -74,9 +74,9 @@ export class HistoryManager implements IHistoryManager {
         throw err;
       }
       if (err.message?.includes('Get')) {
-        throw new StorageError('Failed to get history records', 'read');
+        throw new HistoryStorageError('Failed to get history records', 'read');
       } else {
-        throw new StorageError('Failed to save history records', 'write');
+        throw new HistoryStorageError('Failed to save history records', 'write');
       }
     }
   }
@@ -95,7 +95,7 @@ export class HistoryManager implements IHistoryManager {
       // 直接返回记录，排序逻辑由调用者根据需求处理
       return records;
     } catch (err) {
-      throw new StorageError('Failed to get history records', 'read');
+      throw new HistoryStorageError('Failed to get history records', 'read');
     }
   }
 
@@ -134,7 +134,7 @@ export class HistoryManager implements IHistoryManager {
       if (err instanceof RecordNotFoundError) {
         throw err;
       }
-      throw new StorageError('Failed to delete record', 'delete');
+      throw new HistoryStorageError('Failed to delete record', 'delete');
     }
   }
 
@@ -166,7 +166,7 @@ export class HistoryManager implements IHistoryManager {
     try {
       await this.storage.removeItem(this.storageKey);
     } catch (err) {
-      throw new StorageError('Failed to clear history', 'delete');
+      throw new HistoryStorageError('Failed to clear history', 'delete');
     }
   }
 
@@ -303,7 +303,7 @@ export class HistoryManager implements IHistoryManager {
       if (err instanceof RecordNotFoundError || err instanceof HistoryError) {
         throw err;
       }
-      throw new StorageError('Failed to get chain', 'read');
+      throw new HistoryStorageError('Failed to get chain', 'read');
     }
   }