@spacex110/core 0.1.11 → 0.1.13

package/package.json

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

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

@@ -123,7 +123,9 @@ const openaiStrategy: ProviderStrategy = {
         // OpenRouter compatibility & Best Practices
         if (typeof window !== 'undefined' && window.location) {
             headers['HTTP-Referer'] = window.location.origin;
-            headers['X-Title'] = document.title || 'AI Selector';
+            // document.title 可能含中文等非 ASCII 字符，HTTP header 只允许 ISO-8859-1
+            const safeTitle = document.title ? document.title.replace(/[^\x20-\x7E]/g, '').slice(0, 80) : 'AI Selector';
+            headers['X-Title'] = safeTitle || 'AI Selector';
         }
         return headers;
     },