@spacex110/core 0.1.11

package/src/strategies.ts

@@ -0,0 +1,469 @@
+import type { Provider, Model, ModelCapability } from './types';
+
+export interface ProviderStrategy {
+    format: string;
+    // 模型列表
+    getModelsEndpoint?: (baseUrl: string, apiKey: string) => string;
+    parseModelsResponse?: (data: any) => Model[];
+    // 聊天 (也用于连接测试)
+    getChatEndpoint: (baseUrl: string, apiKey: string, model: string) => string;
+    buildChatPayload: (model: string, messages: Array<{ role: string; content: string }>, maxTokens?: number) => Record<string, unknown>;
+    parseChatResponse: (data: any) => string;
+    /** 从一个 SSE data 块中提取增量文本（流式）。返回空字符串表示无内容。 */
+    parseStreamChunk?: (data: any) => string;
+    // Headers
+    buildHeaders: (apiKey: string) => Record<string, string>;
+}
+
+/**
+ * 判断模型是否为 OpenAI o 系列 / 推理模型（只接受 max_completion_tokens）。
+ * 其余 OpenAI 兼容厂商（DeepSeek/Qwen/Moonshot 等）只认 max_tokens。
+ */
+function prefersCompletionTokens(model: string): boolean {
+    return /^o\d/.test(model) || /reasoner|thinking|o1|o3|o4/i.test(model);
+}
+
+/**
+ * 从 API 响应中提取模型能力
+ * 支持多种格式：
+ * - OmniRoute: input_modalities, output_modalities, capabilities
+ * - OpenAI: capabilities
+ * - 关键字降级（vision/reasoning 等出现在 id 或 name 中）
+ */
+function detectCapabilities(m: any): ModelCapability[] {
+    const caps = new Set<ModelCapability>();
+
+    // 1. 优先从 input_modalities 推断（OmniRoute 格式）
+    const inputMods: string[] = m.input_modalities || [];
+    if (inputMods.length > 0) {
+        if (inputMods.some((s: string) => /text/i.test(s))) caps.add('text');
+        if (inputMods.some((s: string) => /image|vision/i.test(s))) caps.add('vision');
+        if (inputMods.some((s: string) => /audio/i.test(s))) caps.add('audio');
+        if (inputMods.some((s: string) => /video/i.test(s))) caps.add('video');
+        // 如果没有任何明确的修饰符，默认是文本
+        if (caps.size === 0) caps.add('text');
+        return Array.from(caps);
+    }
+
+    // 2. 从 capabilities 对象推断（OpenAI/OmniRoute 格式）
+    const cap = m.capabilities;
+    if (cap) {
+        if (cap.vision || cap.image) {
+            caps.add('vision');
+            caps.add('text');
+        }
+        if (cap.audio) caps.add('audio');
+        if (cap.video) caps.add('video');
+        if (cap.embeddings) caps.add('embedding');
+        if (caps.size > 0) return Array.from(caps);
+    }
+
+    // 3. 关键字降级（从 id/name 推断）
+    const modelId = (m.id || '').toLowerCase();
+    const modelName = (m.name || '').toLowerCase();
+    const combined = `${modelId} ${modelName}`;
+
+    caps.add('text'); // 默认至少是文本
+
+    if (/vision|image|visual|multimodal|vl|pixtral|llava|bakllava/.test(combined)) {
+        caps.add('vision');
+    }
+    if (/audio|speech|whisper|tts|stt/.test(combined)) {
+        caps.add('audio');
+    }
+    if (/video/.test(combined)) {
+        caps.add('video');
+    }
+    if (/embedding|embed/.test(combined)) {
+        caps.add('embedding');
+    }
+    if (/reasoner|reasoning|thinking|qwq/.test(combined)) {
+        caps.add('reasoning');
+    }
+
+    return Array.from(caps);
+}
+
+export const defaultParseModelsResponse = (data: any): Model[] => {
+    if (Array.isArray(data?.data)) {
+        return data.data
+            .filter((m: any) => m.id)
+            .map((m: any) => {
+                const name =
+                    m.name || m.display_name ||
+                    (m.id.split('/').pop() ?? '')
+                        .replace(/[-_]/g, ' ')
+                        .replace(/\b\w/g, (c: string) => c.toUpperCase());
+                return {
+                    id: m.id,
+                    name,
+                    created: m.created || 0,
+                    contextLength: m.context_length || m.max_context || undefined,
+                    capabilities: detectCapabilities(m),
+                } as any;
+            })
+            .sort((a: any, b: any) => {
+                const diff = (b.created || 0) - (a.created || 0);
+                if (diff !== 0) return diff;
+                return (b.id || '').localeCompare(a.id || '');
+            }); // 最新的排在前面
+    }
+    return [];
+};
+
+const openaiStrategy: ProviderStrategy = {
+    format: 'openai',
+    getModelsEndpoint: (baseUrl) => `${baseUrl}/models`,
+    getChatEndpoint: (baseUrl) => `${baseUrl}/chat/completions`,
+    buildHeaders: (apiKey) => {
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+        };
+        // OpenRouter compatibility & Best Practices
+        if (typeof window !== 'undefined' && window.location) {
+            headers['HTTP-Referer'] = window.location.origin;
+            headers['X-Title'] = document.title || 'AI Selector';
+        }
+        return headers;
+    },
+    buildChatPayload: (model, messages, maxTokens) => {
+        const payload: any = {
+            model,
+            messages,
+        };
+        if (maxTokens) {
+            // o 系列 / 推理模型只接受 max_completion_tokens；DeepSeek/Qwen 等国产兼容厂商只认 max_tokens
+            payload[prefersCompletionTokens(model) ? 'max_completion_tokens' : 'max_tokens'] = maxTokens;
+        }
+        return payload;
+    },
+    parseChatResponse: (data) => {
+        return data.choices?.[0]?.message?.content || '';
+    },
+    parseStreamChunk: (data) => {
+        // OpenAI SSE: { choices: [{ delta: { content } }] }，[DONE] 由调用方过滤
+        return data.choices?.[0]?.delta?.content || '';
+    },
+};
+
+const anthropicStrategy: ProviderStrategy = {
+    format: 'anthropic',
+    getModelsEndpoint: (baseUrl) => `${baseUrl}/models`,
+    getChatEndpoint: (baseUrl) => `${baseUrl}/messages`,
+    buildHeaders: (apiKey) => ({
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'anthropic-dangerous-direct-browser-access': 'true',  // 启用浏览器直连 CORS
+    }),
+    buildChatPayload: (model, messages, maxTokens) => {
+        const payload: any = {
+            model,
+            messages,
+            max_tokens: maxTokens || 1024,  // Anthropic API 强制要求 max_tokens
+        };
+        return payload;
+    },
+    parseChatResponse: (data) => {
+        return data.content?.[0]?.text || '';
+    },
+    parseStreamChunk: (data) => {
+        // Anthropic SSE 事件：content_block_delta -> { delta: { text } }
+        if (data.type === 'content_block_delta') {
+            return data.delta?.text || '';
+        }
+        return '';
+    },
+    // Anthropic 返回: { data: [{ id, display_name, created_at }] }
+    parseModelsResponse: (data) => {
+        if (Array.isArray(data.data)) {
+            return data.data
+                .filter((m: any) => m.id)
+                .map((m: any) => ({
+                    id: m.id,
+                    name: m.display_name || m.id,
+                    created: m.created_at ? new Date(m.created_at).getTime() / 1000 : 0,
+                    capabilities: detectCapabilities(m),
+                }))
+                .sort((a: any, b: any) => (b.created || 0) - (a.created || 0));
+        }
+        return [];
+    },
+};
+
+const geminiStrategy: ProviderStrategy = {
+    format: 'gemini',
+    getModelsEndpoint: (baseUrl, apiKey) => `${baseUrl}/models?key=${apiKey}`,
+    getChatEndpoint: (baseUrl, apiKey, model) => `${baseUrl}/models/${model}:generateContent?key=${apiKey}`,
+    buildHeaders: () => ({
+        'Content-Type': 'application/json',
+    }),
+    buildChatPayload: (_model, messages, maxTokens) => {
+        // 转换 OpenAI 格式的 messages 为 Gemini 格式
+        const contents = messages.map(m => ({
+            role: m.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: m.content }],
+        }));
+        const payload: any = { contents };
+        if (maxTokens) {
+            payload.generationConfig = { maxOutputTokens: maxTokens };
+        }
+        return payload;
+    },
+    parseChatResponse: (data) => {
+        return data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    },
+    parseStreamChunk: (data) => {
+        // Gemini streamGenerateContent SSE
+        return data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    },
+    // Gemini 返回格式: { models: [{ name: "models/gemini-pro", ... }] }
+    parseModelsResponse: (data) => {
+        if (Array.isArray(data.models)) {
+            return data.models
+                .filter((m: any) => m.supportedGenerationMethods?.includes('generateContent'))
+                .map((m: any) => ({
+                    id: m.name.replace('models/', ''), // "models/gemini-pro" -> "gemini-pro"
+                    name: m.displayName || m.name.replace('models/', ''),
+                    created: m.created || 0,
+                    capabilities: detectCapabilities(m),
+                }))
+                .sort((a: any, b: any) => (b.id || '').localeCompare(a.id || ''));
+        }
+        return [];
+    },
+};
+
+const cohereStrategy: ProviderStrategy = {
+    format: 'cohere',
+    getModelsEndpoint: (baseUrl) => `${baseUrl}/models`,
+    getChatEndpoint: (baseUrl) => `${baseUrl}/chat`,
+    buildHeaders: (apiKey) => ({
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+    }),
+    buildChatPayload: (model, messages, maxTokens) => {
+        // Cohere v2 API 使用 messages 格式
+        const payload: any = {
+            model,
+            messages,
+        };
+        if (maxTokens) {
+            payload.max_tokens = maxTokens;
+        }
+        return payload;
+    },
+    parseChatResponse: (data) => {
+        // Cohere v2 响应格式
+        return data.message?.content?.[0]?.text || '';
+    },
+    parseStreamChunk: (data) => {
+        // Cohere v2 SSE: { type: 'content-delta', delta: { message: { content: [{ text }] } } }
+        if (data.type === 'content-delta') {
+            return data.delta?.message?.content?.[0]?.text || '';
+        }
+        return '';
+    },
+};
+
+export const strategyRegistry: Record<string, ProviderStrategy> = {
+    openai: openaiStrategy,
+    anthropic: anthropicStrategy,
+    gemini: geminiStrategy,
+    cohere: cohereStrategy,
+};
+
+export function getStrategy(format: string): ProviderStrategy {
+    return strategyRegistry[format] || openaiStrategy;
+}
+
+// ============================================================================
+// 纯前端直连聊天函数
+// ============================================================================
+
+export interface DirectChatOptions {
+    apiFormat: string;
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    messages: Array<{ role: string; content: string }>;
+    maxTokens?: number;
+}
+
+export interface DirectChatResult {
+    success: boolean;
+    content?: string;
+    message?: string;
+    latencyMs?: number;
+}
+
+/**
+ * 纯前端直连 AI 厂商进行聊天
+ * 注意: 这会将 API Key 暴露在浏览器中，仅适用于 Demo/测试场景
+ */
+export async function sendDirectChat(options: DirectChatOptions): Promise<DirectChatResult> {
+    const { apiFormat, baseUrl, apiKey, model, messages, maxTokens } = options;
+    const strategy = getStrategy(apiFormat);
+
+    const endpoint = strategy.getChatEndpoint(baseUrl, apiKey, model);
+    const headers = strategy.buildHeaders(apiKey);
+    const payload = strategy.buildChatPayload(model, messages, maxTokens);
+
+    const startTime = performance.now();
+
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(payload),
+        });
+
+        const latencyMs = Math.round(performance.now() - startTime);
+
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            return {
+                success: false,
+                message: errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+                latencyMs,
+            };
+        }
+
+        const data = await response.json();
+        const content = strategy.parseChatResponse(data);
+
+        return {
+            success: true,
+            content,
+            latencyMs,
+        };
+    } catch (e) {
+        return {
+            success: false,
+            message: e instanceof Error ? e.message : '网络错误',
+        };
+    }
+}
+
+// ============================================================================
+// 纯前端直连流式聊天
+// ============================================================================
+
+export interface DirectChatStreamOptions extends DirectChatOptions {
+    /** 每收到增量文本时回调，参数为「累计完整文本」 */
+    onDelta: (full: string) => void;
+    /** 可选 AbortSignal */
+    signal?: AbortSignal;
+}
+
+/**
+ * 纯前端直连流式聊天。逐增量回调 onDelta(累计文本)，返回最终完整文本。
+ * 注意: 与 sendDirectChat 一样会把 API Key 暴露在浏览器，仅适用于 Demo/本地场景。
+ */
+export async function sendDirectChatStream(options: DirectChatStreamOptions): Promise<DirectChatResult> {
+    const { apiFormat, baseUrl, apiKey, model, messages, maxTokens, onDelta, signal } = options;
+    const strategy = getStrategy(apiFormat);
+
+    // 计算流式端点：gemini 需改为 streamGenerateContent?alt=sse
+    let endpoint = strategy.getChatEndpoint(baseUrl, apiKey, model);
+    if (apiFormat === 'gemini') {
+        endpoint = `${baseUrl}/models/${model}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
+    }
+
+    const headers = strategy.buildHeaders(apiKey);
+    const payload = strategy.buildChatPayload(model, messages, maxTokens);
+    (payload as any).stream = true;  // gemini 通过端点参数控制流式，stream 字段会被忽略，无副作用
+
+    const startTime = performance.now();
+
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(payload),
+            signal,
+        });
+
+        if (!response.ok || !response.body) {
+            const text = await response.text();
+            let m = `HTTP ${response.status}`;
+            try { const j = JSON.parse(text); m = j.error?.message || j.error || j.message || m; } catch { if (text) m = text.slice(0, 200); }
+            return { success: false, message: m, latencyMs: Math.round(performance.now() - startTime) };
+        }
+
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = '';
+        let full = '';
+
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buf += decoder.decode(value, { stream: true });
+            const lines = buf.split('\n');
+            buf = lines.pop() || '';
+            for (const line of lines) {
+                const s = line.trim();
+                if (!s.startsWith('data:') && !s.startsWith('event:')) continue;
+                // Anthropic SSE 有 event: 行，data: 行才是 JSON
+                if (s.startsWith('event:')) continue;
+                const data = s.slice(5).trim();
+                if (!data || data === '[DONE]') continue;
+                try {
+                    const json = JSON.parse(data);
+                    const delta = strategy.parseStreamChunk ? strategy.parseStreamChunk(json) : '';
+                    if (delta) {
+                        full += delta;
+                        onDelta(full);
+                    }
+                } catch {
+                    // 非 JSON 行（心跳等），忽略
+                }
+            }
+        }
+
+        return { success: true, content: full, latencyMs: Math.round(performance.now() - startTime) };
+    } catch (e) {
+        if (e instanceof Error && e.name === 'AbortError') {
+            return { success: false, message: '请求已取消', latencyMs: Math.round(performance.now() - startTime) };
+        }
+        return {
+            success: false,
+            message: e instanceof Error ? e.message : '网络错误',
+        };
+    }
+}
+
+export interface TestConnectionOptions {
+    apiFormat: string;
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+}
+
+export interface TestConnectionResult {
+    success: boolean;
+    latencyMs?: number;
+    message?: string;
+}
+
+/**
+ * 测试 AI 厂商连接 (通过发送一个简单的聊天请求)
+ */
+export async function testDirectConnection(options: TestConnectionOptions): Promise<TestConnectionResult> {
+    const result = await sendDirectChat({
+        apiFormat: options.apiFormat,
+        baseUrl: options.baseUrl,
+        apiKey: options.apiKey,
+        model: options.model,
+        messages: [{ role: 'user', content: 'Hi' }],
+        // maxTokens: 5, // 不设置 maxTokens 以兼容 o1 等不支持该参数的模型
+    });
+
+    return {
+        success: result.success,
+        latencyMs: result.latencyMs,
+        message: result.success ? undefined : result.message,
+    };
+}