@huyooo/ai-chat-core 0.2.44 → 0.3.2

package/src/protocols/moonshot.ts

@@ -0,0 +1,186 @@
+/**
+ * Moonshot Protocol（Kimi K2.5 OpenAI 兼容 API）
+ *
+ * 完全兼容 OpenAI Chat Completions 格式，主要区别：
+ * - thinking 参数：`"reasoning": {"enabled": true}` + `temperature: 1.0`
+ * - 默认 URL：https://api.moonshot.cn/v1
+ * - 流式 thinking 输出：delta.reasoning_content（与 DeepSeek/GLM 一致）
+ */
+
+import type {
+  Protocol,
+  ProtocolConfig,
+  ProtocolMessage,
+  ProtocolToolDefinition,
+  ProtocolRequestOptions,
+  RawEvent,
+} from './types';
+import { createModuleLogger } from '../logger';
+import { friendlyHttpError } from './error-utils';
+import { readSSEJsonStream } from './sse-reader';
+import { mapOpenAIStream } from './openai-sse';
+import type { OpenAIStreamConfig } from './openai-sse';
+
+const logger = createModuleLogger('MoonshotProtocol');
+
+const DEFAULT_MOONSHOT_URL = 'https://api.moonshot.cn/v1';
+
+const MOONSHOT_SSE_CONFIG: OpenAIStreamConfig = {
+  thinkingField: (delta) => delta.reasoning_content as string | undefined,
+  errorFinishReasons: ['content_filter'],
+  protocolName: 'Moonshot',
+  parseUsage: (usage) => ({
+    promptTokens: (usage.prompt_tokens as number) ?? 0,
+    completionTokens: (usage.completion_tokens as number) ?? 0,
+    totalTokens: (usage.total_tokens as number) ?? 0,
+    cachedTokens: (usage.prompt_tokens_details as Record<string, number> | undefined)?.cached_tokens ?? 0,
+  }),
+};
+
+export class MoonshotProtocol implements Protocol {
+  readonly name = 'moonshot';
+
+  private apiKey: string;
+  private apiUrl: string;
+
+  constructor(config: ProtocolConfig) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl || DEFAULT_MOONSHOT_URL;
+  }
+
+  async *stream(
+    messages: ProtocolMessage[],
+    tools: ProtocolToolDefinition[],
+    options: ProtocolRequestOptions
+  ): AsyncGenerator<RawEvent> {
+    const requestBody = this.buildRequestBody(messages, tools, options);
+    const url = `${this.apiUrl}/chat/completions`;
+
+    logger.debug({
+      url,
+      model: options.model,
+      enableThinking: options.enableThinking,
+      toolsCount: tools.length,
+    }, '发送 Moonshot 请求');
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(requestBody),
+      signal: options.signal,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error({ status: response.status, body: errorText.slice(0, 500) }, 'Moonshot API 错误');
+      yield { type: 'error', error: friendlyHttpError(response.status, errorText, 'Moonshot') };
+      return;
+    }
+
+    const reader = response.body?.getReader();
+    if (!reader) {
+      yield { type: 'error', error: '无法获取响应流' };
+      return;
+    }
+
+    yield* mapOpenAIStream(readSSEJsonStream(reader), MOONSHOT_SSE_CONFIG);
+  }
+
+  private buildRequestBody(
+    messages: ProtocolMessage[],
+    tools: ProtocolToolDefinition[],
+    options: ProtocolRequestOptions
+  ): Record<string, unknown> {
+    const convertedMessages = this.convertMessages(messages);
+
+    const body: Record<string, unknown> = {
+      model: options.model,
+      messages: convertedMessages,
+      stream: true,
+      stream_options: { include_usage: true },
+    };
+
+    // Moonshot thinking 格式：reasoning: {enabled: true}，需 temperature=1.0
+    if (options.enableThinking) {
+      body.reasoning = { enabled: true };
+      body.temperature = 1.0;
+    }
+
+    if (tools.length > 0) {
+      body.tools = tools.map(t => ({
+        type: 'function',
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters,
+        },
+      }));
+    }
+
+    return body;
+  }
+
+  private convertMessages(messages: ProtocolMessage[]): unknown[] {
+    const result: unknown[] = [];
+
+    for (const msg of messages) {
+      switch (msg.role) {
+        case 'system':
+          result.push({ role: 'system', content: msg.content });
+          break;
+
+        case 'user': {
+          const textContent = msg.content || (msg.images?.length ? '请分析这张图片' : '');
+          if (msg.images?.length) {
+            const content: unknown[] = [{ type: 'text', text: textContent }];
+            for (const img of msg.images) {
+              content.push({
+                type: 'image_url',
+                image_url: { url: img.startsWith('data:') ? img : `data:image/jpeg;base64,${img}` },
+              });
+            }
+            result.push({ role: 'user', content });
+          } else {
+            result.push({ role: 'user', content: textContent });
+          }
+          break;
+        }
+
+        case 'assistant':
+          if (msg.toolCalls?.length) {
+            result.push({
+              role: 'assistant',
+              content: msg.content || null,
+              ...(msg.thinkingContent ? { reasoning_content: msg.thinkingContent } : {}),
+              tool_calls: msg.toolCalls.map(tc => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.name, arguments: tc.arguments },
+              })),
+            });
+          } else {
+            result.push({ role: 'assistant', content: msg.content });
+          }
+          break;
+
+        case 'tool':
+          result.push({
+            role: 'tool',
+            tool_call_id: msg.toolCallId,
+            content: msg.content,
+          });
+          break;
+      }
+    }
+
+    return result;
+  }
+
+}
+
+export function createMoonshotProtocol(config: ProtocolConfig): MoonshotProtocol {
+  return new MoonshotProtocol(config);
+}

package/src/protocols/openai-sse.ts

@@ -0,0 +1,156 @@
+/**
+ * Layer 2: OpenAI 兼容 SSE 语义映射器
+ *
+ * 消费 Layer 1 的 JSON 流，映射为 RawEvent。
+ * 通过 config 注入协议差异，零 if/else 分支。
+ *
+ * 共享逻辑：
+ * - choices[0].delta.content → text_delta
+ * - delta.tool_calls → tool_call_start / tool_call_done
+ * - thinking 状态机（首段 text 自动关闭 thinking）
+ * - [流结束] tool_call_done 发射 + done 事件
+ *
+ * 使用方：deepseek, glm, moonshot, grok, openai
+ */
+
+import type { RawEvent, RawToolCall, RawTokenUsage } from './types';
+import { createModuleLogger } from '../logger';
+
+const logger = createModuleLogger('OpenAISSE');
+
+// ==================== 配置接口 ====================
+
+export interface OpenAIStreamConfig {
+  /** 从 delta 提取 thinking 内容（不提供 = 不支持 thinking） */
+  thinkingField?: (delta: Record<string, unknown>) => string | undefined;
+  /** 厂商特有的 finish_reason → error 映射（列出视为 error 的 reason） */
+  errorFinishReasons?: string[];
+  /** 协议名（用于错误消息） */
+  protocolName?: string;
+  /** 自定义 usage 提取（不提供则用默认 OpenAI 格式） */
+  parseUsage?: (usage: Record<string, unknown>) => RawTokenUsage;
+}
+
+// ==================== 默认 usage 提取 ====================
+
+function defaultParseUsage(usage: Record<string, unknown>): RawTokenUsage {
+  const details = usage.completion_tokens_details as Record<string, number> | undefined;
+  const promptDetails = usage.prompt_tokens_details as Record<string, number> | undefined;
+  return {
+    promptTokens: (usage.prompt_tokens as number) ?? 0,
+    completionTokens: (usage.completion_tokens as number) ?? 0,
+    totalTokens: (usage.total_tokens as number) ?? 0,
+    reasoningTokens: details?.reasoning_tokens ?? 0,
+    cachedTokens: promptDetails?.cached_tokens ?? (usage.prompt_cache_hit_tokens as number) ?? 0,
+  };
+}
+
+// ==================== finish_reason 映射 ====================
+
+function mapFinishReason(
+  reason: string | undefined,
+  errorReasons?: string[],
+): RawEvent['finishReason'] {
+  if (!reason) return 'stop';
+  if (reason === 'tool_calls' || reason === 'length' || reason === 'error') return reason;
+  if (errorReasons?.includes(reason)) return 'error';
+  return 'stop';
+}
+
+// ==================== 核心映射器 ====================
+
+/**
+ * 将 OpenAI 兼容的 JSON 流映射为 RawEvent 流
+ *
+ * @param jsonStream - Layer 1 的 readSSEJsonStream 输出
+ * @param config - 协议差异配置（可选，不传则为标准 OpenAI 行为）
+ */
+export async function* mapOpenAIStream(
+  jsonStream: AsyncGenerator<Record<string, unknown>>,
+  config?: OpenAIStreamConfig,
+): AsyncGenerator<RawEvent> {
+  const toolCallsMap = new Map<number, RawToolCall>();
+  let textStarted = false;
+  let thinkingDone = false;
+  let lastUsage: RawTokenUsage | undefined;
+  let lastFinishReason: string | undefined;
+
+  const parseUsage = config?.parseUsage ?? defaultParseUsage;
+  const thinkingField = config?.thinkingField;
+
+  for await (const json of jsonStream) {
+    // Usage
+    if (json.usage) {
+      lastUsage = parseUsage(json.usage as Record<string, unknown>);
+    }
+
+    const choices = json.choices as Array<Record<string, unknown>> | undefined;
+    const choice = choices?.[0];
+    if (!choice) continue;
+
+    const delta = choice.delta as Record<string, unknown> | undefined;
+    if (!delta) continue;
+
+    // Thinking
+    if (thinkingField && !thinkingDone) {
+      const thinking = thinkingField(delta);
+      if (thinking) {
+        yield { type: 'thinking_delta', delta: thinking };
+      }
+    }
+
+    // Text
+    const content = delta.content as string | undefined;
+    if (content) {
+      if (!textStarted && !thinkingDone && thinkingField) {
+        thinkingDone = true;
+        yield { type: 'thinking_done' };
+      }
+      textStarted = true;
+      yield { type: 'text_delta', delta: content };
+    }
+
+    // Tool calls
+    const toolCalls = delta.tool_calls as Array<Record<string, unknown>> | undefined;
+    if (toolCalls?.length) {
+      for (const tc of toolCalls) {
+        const index = (tc.index as number) ?? 0;
+        const fn = tc.function as Record<string, string> | undefined;
+        const existing = toolCallsMap.get(index);
+
+        if (existing) {
+          if (fn?.arguments) {
+            existing.arguments += fn.arguments;
+          }
+        } else {
+          const id = (tc.id as string) || `call_${index}`;
+          const name = fn?.name || '';
+          toolCallsMap.set(index, { id, name, arguments: fn?.arguments || '' });
+          yield { type: 'tool_call_start', toolCall: { id, name } };
+        }
+      }
+    }
+
+    // Finish reason
+    const finishReason = choice.finish_reason as string | undefined;
+    if (finishReason) {
+      lastFinishReason = finishReason;
+    }
+  }
+
+  // 流结束：发射累积的 tool calls + done
+  const allToolCalls = Array.from(toolCallsMap.values());
+  if (allToolCalls.length > 0) {
+    for (const tc of allToolCalls) {
+      yield { type: 'tool_call_done', toolCall: tc };
+    }
+    yield { type: 'done', finishReason: 'tool_calls', usage: lastUsage };
+  } else {
+    const reason = mapFinishReason(lastFinishReason, config?.errorFinishReasons);
+    if (reason === 'error') {
+      const name = config?.protocolName ?? 'LLM';
+      yield { type: 'error', error: `${name} 推理异常 (finish_reason: ${lastFinishReason})` };
+    }
+    yield { type: 'done', finishReason: reason, usage: lastUsage };
+  }
+}

package/src/protocols/openai.ts

@@ -0,0 +1,97 @@
+/**
+ * OpenAI Protocol（Responses API）
+ *
+ * 使用 /v1/responses 端点，统一支持所有 OpenAI 模型（GPT、Codex、o-series）。
+ *
+ * 支持直连或代理（如 llm.huyooo.com）：
+ * - 直连：apiUrl = https://api.openai.com/v1，Key 走 Authorization
+ * - 代理：apiUrl = https://llm.huyooo.com/openai，Key 为代理认证
+ */
+
+import type {
+  Protocol,
+  ProtocolConfig,
+  ProtocolMessage,
+  ProtocolToolDefinition,
+  ProtocolRequestOptions,
+  RawEvent,
+} from './types';
+import { createModuleLogger } from '../logger';
+import { friendlyHttpError } from './error-utils';
+import { convertToResponsesInput, convertToResponsesTools, mapResponsesStream } from './responses-sse';
+
+const logger = createModuleLogger('OpenAIProtocol');
+
+const DEFAULT_OPENAI_URL = 'https://api.openai.com/v1';
+
+export class OpenAIProtocol implements Protocol {
+  readonly name = 'openai';
+
+  private apiKey: string;
+  private apiUrl: string;
+
+  constructor(config: ProtocolConfig) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl ?? DEFAULT_OPENAI_URL;
+  }
+
+  async *stream(
+    messages: ProtocolMessage[],
+    tools: ProtocolToolDefinition[],
+    options: ProtocolRequestOptions,
+  ): AsyncGenerator<RawEvent> {
+    const body: Record<string, unknown> = {
+      model: options.model,
+      input: convertToResponsesInput(messages),
+      stream: true,
+      max_output_tokens: options.maxOutputTokens,
+      store: false,
+    };
+
+    if (options.enableThinking) {
+      body.reasoning = { effort: 'high' };
+    }
+
+    if (tools.length > 0) {
+      body.tools = convertToResponsesTools(tools);
+    }
+
+    const url = `${this.apiUrl}/responses`;
+
+    logger.debug({
+      url: url.replace(this.apiKey, '***'),
+      model: options.model,
+      enableThinking: options.enableThinking,
+      toolsCount: tools.length,
+    }, 'OpenAI Responses 请求');
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal: options.signal,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error({ status: response.status, body: errorText.slice(0, 500) }, 'OpenAI API 错误');
+      yield { type: 'error', error: friendlyHttpError(response.status, errorText, 'OpenAI') };
+      return;
+    }
+
+    const reader = response.body?.getReader();
+    if (!reader) {
+      yield { type: 'error', error: '无法获取响应流' };
+      return;
+    }
+
+    yield* mapResponsesStream(reader, { protocolName: 'OpenAI' });
+  }
+}
+
+export function createOpenAIProtocol(config: ProtocolConfig): OpenAIProtocol {
+  return new OpenAIProtocol(config);
+}