@spacex110/core 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@spacex110/core",
-    "version": "0.1.12",
+    "version": "0.1.14",
     "description": "Framework-agnostic AI Provider Selector core utilities",
     "type": "module",
     "main": "./dist/index.js",

package/src/api.ts

@@ -58,7 +58,7 @@ export async function testConnection(options: TestConnectionOptions): Promise<Te
             };
         }
 
-        const headers = strategy.buildHeaders(apiKey);
+        const headers = strategy.buildHeaders(apiKey, actualBaseUrl);
         // 使用聊天接口进行测试，发送最简单的请求
         const testPayload = strategy.buildChatPayload(targetModel, [{ role: 'user', content: 'Hi' }]);
         const endpoint = strategy.getChatEndpoint(actualBaseUrl, apiKey, targetModel);
@@ -124,7 +124,7 @@ export async function fetchModels(options: FetchModelsOptions): Promise<Model[]>
             const strategy = getStrategy(provider.apiFormat);
             if (strategy.getModelsEndpoint) {
                 const endpoint = strategy.getModelsEndpoint(baseUrl || provider.baseUrl, apiKey || '');
-                const headers = strategy.buildHeaders(apiKey || '');
+                const headers = strategy.buildHeaders(apiKey || '', baseUrl || provider.baseUrl);
 
                 const response = await fetch(endpoint, {
                     method: 'GET',

package/src/channel-manager.ts

@@ -58,6 +58,8 @@ export interface ChannelManagerOptions {
     storagePrefix?: string;
     /** 当前激活通道的存储键 */
     activeChannelKey?: string;
+    /** 能力默认通道的存储键 */
+    capabilityDefaultsKey?: string;
     /** 后端代理地址（可选，用于解决 CORS 问题） */
     proxyUrl?: string;
 }
@@ -98,17 +100,21 @@ export class AIChannelManager {
     private activeChannelId: string | null = null;
     private storagePrefix: string;
     private activeChannelKey: string;
+    private capabilityDefaultsKey: string;
+    private capabilityDefaults: Record<ModelCapability, string> = {} as Record<ModelCapability, string>;
     private proxyUrl?: string;
     private listeners: Map<ChannelEventType, Set<ChannelEventListener>> = new Map();
 
     constructor(options: ChannelManagerOptions = {}) {
         this.storagePrefix = options.storagePrefix || 'ai_channel';
         this.activeChannelKey = options.activeChannelKey || 'ai_active_channel';
+        this.capabilityDefaultsKey = options.capabilityDefaultsKey || 'ai_capability_defaults';
         this.proxyUrl = options.proxyUrl;
         this.storageAdapter = options.storageAdapter || defaultStorageAdapter;
 
         this.loadChannels();
         this.loadActiveChannel();
+        this.loadCapabilityDefaults();
     }
 
     // ==================== 事件系统 ====================
@@ -190,6 +196,37 @@ export class AIChannelManager {
         }
     }
 
+    private loadCapabilityDefaults(): void {
+        try {
+            const raw = this.storageAdapter.get(this.capabilityDefaultsKey);
+            if (raw) {
+                const parsed = JSON.parse(raw);
+                this.capabilityDefaults = parsed as Record<ModelCapability, string>;
+            }
+        } catch (e) {
+            console.error('Failed to load capability defaults:', e);
+        }
+    }
+
+    private saveCapabilityDefaults(): void {
+        try {
+            const keys = Object.keys(this.capabilityDefaults).filter(
+                k => this.capabilityDefaults[k as ModelCapability]
+            );
+            if (keys.length > 0) {
+                const obj: Record<string, string> = {};
+                for (const k of keys) {
+                    obj[k] = this.capabilityDefaults[k as ModelCapability]!;
+                }
+                this.storageAdapter.set(this.capabilityDefaultsKey, JSON.stringify(obj));
+            } else {
+                this.storageAdapter.remove(this.capabilityDefaultsKey);
+            }
+        } catch (e) {
+            console.error('Failed to save capability defaults:', e);
+        }
+    }
+
     // ==================== 通道 CRUD ====================
 
     /** 添加通道 */
@@ -388,6 +425,118 @@ export class AIChannelManager {
         this.saveActiveChannel();
     }
 
+    // ==================== 能力默认通道 ====================
+
+    /**
+     * 为指定能力类型设置默认通道
+     * 当调用 getChannelForCapability 时，优先返回此通道
+     */
+    setDefaultForCapability(capability: ModelCapability, channelId: string): void {
+        if (!this.getChannel(channelId)) {
+            throw new Error(`Channel not found: ${channelId}`);
+        }
+        this.capabilityDefaults[capability] = channelId;
+        this.saveCapabilityDefaults();
+        this.emit('update', { type: 'capabilityDefault', capability, channelId });
+    }
+
+    /**
+     * 获取指定能力类型的默认通道 ID
+     * 返回 undefined 表示未设置
+     */
+    getDefaultForCapability(capability: ModelCapability): string | undefined {
+        return this.capabilityDefaults[capability] || undefined;
+    }
+
+    /**
+     * 清除指定能力类型的默认通道
+     */
+    clearDefaultForCapability(capability: ModelCapability): void {
+        delete this.capabilityDefaults[capability];
+        this.saveCapabilityDefaults();
+    }
+
+    /**
+     * 获取所有能力类型的默认通道映射
+     * 返回 { capability: channelId } 的对象
+     */
+    getAllCapabilityDefaults(): Record<string, string> {
+        return { ...this.capabilityDefaults };
+    }
+
+    /**
+     * 根据能力类型获取最适合的通道（带降级链）
+     *
+     * 降级链：
+     *   1. 该能力类型的显式默认通道
+     *   2. 具有该能力且最后使用时间最新的通道
+     *   3. 全局激活通道
+     *   4. 第一个可用通道
+     */
+    getChannelForCapability(capability: ModelCapability): ChannelConfig | undefined {
+        // 1. 显式默认
+        const defaultId = this.capabilityDefaults[capability];
+        if (defaultId) {
+            const ch = this.getChannel(defaultId);
+            if (ch) return ch;
+        }
+
+        // 2. 该能力中最近使用的
+        const byCap = this.getChannelsByCapability(capability)
+            .filter(c => c.lastUsedAt)
+            .sort((a, b) => (b.lastUsedAt || 0) - (a.lastUsedAt || 0));
+        if (byCap.length > 0) return byCap[0];
+
+        // 3. 全局激活
+        const active = this.getActiveChannel();
+        if (active) return active;
+
+        // 4. 第一个可用
+        return this.channels[0];
+    }
+
+    /**
+     * 使用指定能力类型的默认通道发送聊天请求
+     * 自动选择合适的通道，无需手动指定 channelId
+     */
+    async chatForCapability(
+        capability: ModelCapability,
+        message: string,
+        options?: {
+            messages?: Array<{ role: string; content: string }>;
+            maxTokens?: number;
+        }
+    ): Promise<ChatResult> {
+        const channel = this.getChannelForCapability(capability);
+        if (!channel) {
+            throw new Error(`No available channel for capability: ${capability}`);
+        }
+        return this.chatWith(channel.id, message, options);
+    }
+
+    /**
+     * 使用指定能力类型的默认通道发送流式聊天请求
+     */
+    async chatStreamForCapability(
+        capability: ModelCapability,
+        message: string,
+        options?: {
+            messages?: Array<{ role: string; content: string }>;
+            maxTokens?: number;
+            signal?: AbortSignal;
+            onDelta?: (full: string) => void;
+        }
+    ): Promise<ChatResult> {
+        const channel = this.getChannelForCapability(capability);
+        if (!channel) {
+            throw new Error(`No available channel for capability: ${capability}`);
+        }
+        return this.chatWithStream(channel.id, message, {
+            ...options,
+            onDelta: options?.onDelta || ((_: string) => {}),
+        });
+    }
+
     // ==================== 模型查询 ====================
 
     /** 获取 Provider 的可用模型列表（动态获取 + 静态兜底） */
@@ -751,6 +900,8 @@ export class AIChannelManager {
         this.channels = [];
         this.activeChannelId = null;
         this.saveActiveChannel();
+        this.capabilityDefaults = {} as Record<ModelCapability, string>;
+        this.saveCapabilityDefaults();
         this.emit('clear', {});
     }
 

package/src/strategies.ts

@@ -12,7 +12,7 @@ export interface ProviderStrategy {
     /** 从一个 SSE data 块中提取增量文本（流式）。返回空字符串表示无内容。 */
     parseStreamChunk?: (data: any) => string;
     // Headers
-    buildHeaders: (apiKey: string) => Record<string, string>;
+    buildHeaders: (apiKey: string, baseUrl?: string) => Record<string, string>;
 }
 
 /**
@@ -115,13 +115,16 @@ const openaiStrategy: ProviderStrategy = {
     format: 'openai',
     getModelsEndpoint: (baseUrl) => `${baseUrl}/models`,
     getChatEndpoint: (baseUrl) => `${baseUrl}/chat/completions`,
-    buildHeaders: (apiKey) => {
+    buildHeaders: (apiKey, baseUrl) => {
         const headers: Record<string, string> = {
             'Content-Type': 'application/json',
             'Authorization': `Bearer ${apiKey}`,
         };
-        // OpenRouter compatibility & Best Practices
-        if (typeof window !== 'undefined' && window.location) {
+        // 仅对 OpenRouter 加 HTTP-Referer / X-Title（OpenRouter Best Practices 推荐）；
+        // 其他 OpenAI 兼容厂商（如 DeepSeek/月之暗面/MiniMax/通义/智谱等）的 CORS 预检响应
+        // 通常不包含这两个头，加了会导致浏览器拒绝实际请求（net::ERR_FAILED）。
+        const isOpenRouter = !!baseUrl && /openrouter\.ai/i.test(baseUrl);
+        if (isOpenRouter && typeof window !== 'undefined' && window.location) {
             headers['HTTP-Referer'] = window.location.origin;
             // document.title 可能含中文等非 ASCII 字符，HTTP header 只允许 ISO-8859-1
             const safeTitle = document.title ? document.title.replace(/[^\x20-\x7E]/g, '').slice(0, 80) : 'AI Selector';
@@ -309,7 +312,7 @@ export async function sendDirectChat(options: DirectChatOptions): Promise<Direct
     const strategy = getStrategy(apiFormat);
 
     const endpoint = strategy.getChatEndpoint(baseUrl, apiKey, model);
-    const headers = strategy.buildHeaders(apiKey);
+    const headers = strategy.buildHeaders(apiKey, baseUrl);
     const payload = strategy.buildChatPayload(model, messages, maxTokens);
 
     const startTime = performance.now();
@@ -373,7 +376,7 @@ export async function sendDirectChatStream(options: DirectChatStreamOptions): Pr
         endpoint = `${baseUrl}/models/${model}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
     }
 
-    const headers = strategy.buildHeaders(apiKey);
+    const headers = strategy.buildHeaders(apiKey, baseUrl);
     const payload = strategy.buildChatPayload(model, messages, maxTokens);
     (payload as any).stream = true;  // gemini 通过端点参数控制流式，stream 字段会被忽略，无副作用