@userdaoo/iflow-api-bridge 0.1.1 → 0.1.2

package/src/adapter.ts

@@ -1,6 +1,6 @@
 /**
  * iFlow SDK 适配器（使用子进程模式）
- * 封装与 iFlow CLI 的通信
+ * 封装与 iFlow CLI 的通信，支持对话上下文管理
  */
 
 import { spawn, type ChildProcess } from 'child_process';
@@ -27,24 +27,115 @@ export interface IFlowAdapterOptions {
   apiKey?: string;
   baseUrl?: string;
   timeout?: number;
+  maxHistoryLength?: number;
+}
+
+interface Message {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+interface Conversation {
+  messages: Message[];
+  lastAccessTime: number;
 }
 
-/**
- * iFlow 适配器 - 使用子进程模式
- */
 export class IFlowAdapter {
   private options: IFlowAdapterOptions;
-  private defaultTimeout = 120000; // 2分钟默认超时
+  private defaultTimeout = 300000;
+  private conversations: Map<string, Conversation> = new Map();
+  private readonly maxHistoryLength: number;
+  private cleanupInterval: NodeJS.Timeout | null = null;
 
   constructor(options: IFlowAdapterOptions = {}) {
     this.options = options;
+    this.maxHistoryLength = options.maxHistoryLength || 20;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredConversations();
+    }, 30 * 60 * 1000);
+  }
+
+  private getConversation(conversationId: string): Conversation {
+    let conversation = this.conversations.get(conversationId);
+    if (!conversation) {
+      conversation = {
+        messages: [],
+        lastAccessTime: Date.now(),
+      };
+      this.conversations.set(conversationId, conversation);
+    } else {
+      conversation.lastAccessTime = Date.now();
+    }
+    return conversation;
   }
 
-  /**
-   * 发送消息并获取完整响应（非流式）
-   */
-  async sendMessage(prompt: string): Promise<IFlowResponse> {
-    console.log('[Adapter] 发送消息（非流式）:', prompt.substring(0, 100));
+  private buildPromptWithHistory(
+    conversationId: string,
+    systemMessage: string | undefined,
+    userMessage: string
+  ): string {
+    const conversation = this.getConversation(conversationId);
+    const parts: string[] = [];
+
+    if (systemMessage) {
+      parts.push(`System: ${systemMessage}`);
+    }
+
+    for (const msg of conversation.messages) {
+      if (msg.role === 'user') {
+        parts.push(`User: ${msg.content}`);
+      } else if (msg.role === 'assistant') {
+        parts.push(`Assistant: ${msg.content}`);
+      }
+    }
+
+    parts.push(`User: ${userMessage}`);
+    return parts.join('\n\n');
+  }
+
+  private saveMessage(conversationId: string, role: 'user' | 'assistant', content: string): void {
+    const conversation = this.getConversation(conversationId);
+    conversation.messages.push({ role, content });
+
+    if (conversation.messages.length > this.maxHistoryLength) {
+      const systemMessages = conversation.messages.filter(m => m.role === 'system');
+      const otherMessages = conversation.messages.filter(m => m.role !== 'system');
+      const keepCount = this.maxHistoryLength - systemMessages.length;
+      conversation.messages = [
+        ...systemMessages,
+        ...otherMessages.slice(-keepCount),
+      ];
+    }
+    conversation.lastAccessTime = Date.now();
+  }
+
+  private cleanupExpiredConversations(): void {
+    const now = Date.now();
+    const expireTime = 24 * 60 * 60 * 1000;
+    let cleaned = 0;
+
+    for (const [id, conversation] of this.conversations.entries()) {
+      if (now - conversation.lastAccessTime > expireTime) {
+        this.conversations.delete(id);
+        cleaned++;
+      }
+    }
+
+    if (cleaned > 0) {
+      console.log(`[Adapter] 清理了 ${cleaned} 个过期会话`);
+    }
+  }
+
+  async sendMessage(
+    conversationId: string,
+    systemMessage: string | undefined,
+    userMessage: string
+  ): Promise<IFlowResponse> {
+    const prompt = this.buildPromptWithHistory(conversationId, systemMessage, userMessage);
+    console.log(`[Adapter] 发送消息（非流式）会话: ${conversationId}`);
+    console.log(`[Adapter] 历史消息数: ${this.getConversation(conversationId).messages.length}`);
+
+    this.saveMessage(conversationId, 'user', userMessage);
 
     return new Promise((resolve, reject) => {
       const args = ['-p', prompt];
@@ -52,7 +143,7 @@ export class IFlowAdapter {
         args.push('-m', this.options.model);
       }
 
-      console.log('[Adapter] 启动 iflow:', args.join(' '));
+      console.log('[Adapter] 启动 iflow:', args.slice(0, 3).join(' ') + '...');
       const child = spawn('iflow', args, {
         stdio: ['ignore', 'pipe', 'pipe'],
       });
@@ -82,11 +173,12 @@ export class IFlowAdapter {
         console.log('[Adapter] iFlow 退出，code:', code);
 
         if (code !== 0 && code !== null) {
-          console.error('[Adapter] iFlow stderr:', stderr);
+          console.error('[Adapter] iFlow stderr:', stderr.substring(0, 500));
         }
 
-        // 解析响应
         const content = this.parseResponse(stdout);
+        this.saveMessage(conversationId, 'assistant', content);
+
         resolve({
           content,
           stopReason: code === 0 ? 'end_turn' : 'error',
@@ -95,24 +187,31 @@ export class IFlowAdapter {
     });
   }
 
-  /**
-   * 发送消息并获取流式响应
-   */
-  async *sendMessageStream(prompt: string): AsyncGenerator<StreamChunk> {
-    console.log('[Adapter] 发送消息（流式）:', prompt.substring(0, 100));
+  async *sendMessageStream(
+    conversationId: string,
+    systemMessage: string | undefined,
+    userMessage: string
+  ): AsyncGenerator<StreamChunk> {
+    const prompt = this.buildPromptWithHistory(conversationId, systemMessage, userMessage);
+    console.log(`[Adapter] 发送消息（流式）会话: ${conversationId}`);
+    console.log(`[Adapter] 历史消息数: ${this.getConversation(conversationId).messages.length}`);
+
+    this.saveMessage(conversationId, 'user', userMessage);
 
     const args = ['-p', prompt];
     if (this.options.model) {
       args.push('-m', this.options.model);
     }
 
-    console.log('[Adapter] 启动 iflow:', args.join(' '));
+    console.log('[Adapter] 启动 iflow:', args.slice(0, 3).join(' ') + '...');
     const child = spawn('iflow', args, {
       stdio: ['ignore', 'pipe', 'pipe'],
     });
 
     let buffer = '';
     let isDone = false;
+    let fullContent = '';
+    
     const timeout = setTimeout(() => {
       if (!isDone) {
         child.kill('SIGTERM');
@@ -127,23 +226,20 @@ export class IFlowAdapter {
 
     child.stderr?.on('data', (data) => {
       const msg = data.toString();
-      console.log('[Adapter] iFlow stderr:', msg.trim());
+      console.log('[Adapter] iFlow stderr:', msg.trim().substring(0, 200));
     });
 
-    // 模拟流式输出 - 逐字符发送
     let lastSentIndex = 0;
     while (!isDone) {
-      // 检查进程是否结束
       if (child.exitCode !== null) {
         isDone = true;
       }
 
-      // 发送新内容
       if (buffer.length > lastSentIndex) {
         const newContent = buffer.slice(lastSentIndex);
         lastSentIndex = buffer.length;
+        fullContent += newContent;
         
-        // 逐行或逐字符发送
         const lines = newContent.split('\n');
         for (const line of lines) {
           if (line.trim()) {
@@ -162,28 +258,27 @@ export class IFlowAdapter {
 
     clearTimeout(timeout);
     
-    // 发送剩余内容
     if (buffer.length > lastSentIndex) {
+      const remaining = buffer.slice(lastSentIndex);
+      fullContent += remaining;
       yield {
         type: 'content',
-        content: buffer.slice(lastSentIndex),
+        content: remaining,
       };
     }
 
+    const finalContent = this.parseResponse(fullContent);
+    this.saveMessage(conversationId, 'assistant', finalContent);
+
     yield { type: 'done' };
   }
 
-  /**
-   * 解析 iFlow 输出，提取实际回复内容
-   */
   private parseResponse(stdout: string): string {
-    // 尝试提取 <Execution Info> 之前的内容作为回复
     const executionInfoMatch = stdout.match(/<Execution Info>[\s\S]*$/);
     if (executionInfoMatch) {
       return stdout.substring(0, executionInfoMatch.index).trim();
     }
 
-    // 如果没有 Execution Info，返回全部内容（去掉开头的警告）
     const lines = stdout.split('\n');
     const startIndex = lines.findIndex((line) => 
       !line.includes('DeprecationWarning') && 
@@ -198,30 +293,33 @@ export class IFlowAdapter {
     return stdout.trim();
   }
 
-  /**
-   * 连接到 iFlow
-   */
   async connect(): Promise<void> {
-    // 子进程模式不需要持久连接
-    console.log('[Adapter] 子进程模式已就绪');
+    console.log('[Adapter] 子进程模式已就绪，支持上下文管理');
   }
 
-  /**
-   * 断开连接
-   */
   disconnect(): void {
-    // 子进程模式不需要断开连接
-    console.log('[Adapter] 子进程模式断开（无操作）');
+    console.log('[Adapter] 子进程模式断开，清理资源...');
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.conversations.clear();
   }
 
-  /**
-   * 检查是否已连接
-   */
   isConnected(): boolean {
-    // 子进程模式总是"已连接"
     return true;
   }
+
+  getStats(): { conversationCount: number; totalMessages: number } {
+    let totalMessages = 0;
+    for (const conv of this.conversations.values()) {
+      totalMessages += conv.messages.length;
+    }
+    return {
+      conversationCount: this.conversations.size,
+      totalMessages,
+    };
+  }
 }
 
 export default IFlowAdapter;
-

package/src/openai/transformer.ts

@@ -12,23 +12,14 @@ import type {
   ToolCall,
 } from './types.js';
 
-/**
- * 生成唯一 ID
- */
 export function generateId(): string {
   return `chatcmpl-${Date.now().toString(36)}${Math.random().toString(36).substring(2, 10)}`;
 }
 
-/**
- * 获取当前时间戳
- */
 export function getTimestamp(): number {
   return Math.floor(Date.now() / 1000);
 }
 
-/**
- * 将 OpenAI 消息格式转换为 iFlow 文本格式
- */
 export function messagesToIFlowPrompt(messages: ChatCompletionMessage[]): string {
   return messages.map(msg => {
     if (typeof msg.content === 'string') {
@@ -38,9 +29,26 @@ export function messagesToIFlowPrompt(messages: ChatCompletionMessage[]): string
   }).join('\n\n');
 }
 
-/**
- * 创建流式响应块
- */
+export function extractMessages(messages: ChatCompletionMessage[]): {
+  systemMessage: string | undefined;
+  userMessage: string;
+} {
+  let systemMessage: string | undefined;
+  let userMessage = '';
+
+  for (const msg of messages) {
+    if (typeof msg.content !== 'string') continue;
+
+    if (msg.role === 'system') {
+      systemMessage = msg.content;
+    } else if (msg.role === 'user') {
+      userMessage = msg.content;
+    }
+  }
+
+  return { systemMessage, userMessage };
+}
+
 export function createStreamChunk(
   id: string,
   model: string,
@@ -62,9 +70,6 @@ export function createStreamChunk(
   };
 }
 
-/**
- * 创建完整响应
- */
 export function createCompletionResponse(
   id: string,
   model: string,
@@ -91,17 +96,10 @@ export function createCompletionResponse(
   };
 }
 
-/**
- * 估算 token 数量（简化版）
- */
 export function estimateTokens(text: string): number {
-  // 简化估算：假设平均每 4 个字符一个 token
   return Math.ceil(text.length / 4);
 }
 
-/**
- * 计算使用量
- */
 export function calculateUsage(prompt: string, completion: string): UsageInfo {
   const promptTokens = estimateTokens(prompt);
   const completionTokens = estimateTokens(completion);
@@ -113,30 +111,28 @@ export function calculateUsage(prompt: string, completion: string): UsageInfo {
   };
 }
 
-/**
- * SSE 格式化
- */
 export function formatSSE(data: unknown): string {
   return `data: ${JSON.stringify(data)}\n\n`;
 }
 
-/**
- * SSE 结束标记
- */
 export const SSE_DONE = 'data: [DONE]\n\n';
 
 /**
- * 支持的模型列表
+ * iFlow 支持的模型列表
+ * 基于用户实际的 iflow CLI 配置
  */
 export const AVAILABLE_MODELS = [
-  { id: 'iflow-default', name: 'iFlow Default' },
-  { id: 'iflow-claude', name: 'iFlow Claude' },
-  { id: 'iflow-gpt-4', name: 'iFlow GPT-4' },
+  { id: 'glm-4.7', name: 'GLM-4.7 (Default)' },
+  { id: 'iflow-rome-30ba3b', name: 'iFlow-ROME-30BA3B (Preview)' },
+  { id: 'deepseek-v3.2', name: 'DeepSeek-V3.2' },
+  { id: 'glm-5', name: 'GLM-5' },
+  { id: 'qwen3-coder-plus', name: 'Qwen3-Coder-Plus' },
+  { id: 'kimi-k2-thinking', name: 'Kimi-K2-Thinking' },
+  { id: 'minimax-m2.5', name: 'MiniMax-M2.5' },
+  { id: 'kimi-k2.5', name: 'Kimi-K2.5' },
+  { id: 'kimi-k2-0905', name: 'Kimi-K2-0905' },
 ];
 
-/**
- * 获取默认模型 ID
- */
 export function getDefaultModel(): string {
-  return 'kimi-k2.5';
-}
+  return 'glm-4.7';
+}

package/src/server.ts

@@ -15,7 +15,7 @@ import {
 import {
   generateId,
   getTimestamp,
-  messagesToIFlowPrompt,
+  extractMessages,
   createCompletionResponse,
   createStreamChunk,
   calculateUsage,
@@ -43,6 +43,7 @@ export class IFlowAPIServer {
     this.app = express();
     this.adapter = new IFlowAdapter({
       model: options.model,
+      maxHistoryLength: 20,
     });
 
     this.setupMiddleware();
@@ -95,9 +96,12 @@ export class IFlowAPIServer {
   private setupRoutes(): void {
     // 健康检查
     this.app.get('/health', (req: Request, res: Response) => {
+      const stats = this.adapter.getStats();
       res.json({
         status: 'ok',
         connected: this.adapter.isConnected(),
+        conversations: stats.conversationCount,
+        totalMessages: stats.totalMessages,
         timestamp: new Date().toISOString(),
       });
     });
@@ -119,7 +123,6 @@ export class IFlowAPIServer {
     // 聊天完成
     this.app.post('/v1/chat/completions', async (req: Request, res: Response) => {
       console.log(`[${new Date().toISOString()}] 收到聊天请求`);
-      console.log('请求体:', JSON.stringify(req.body, null, 2));
 
       try {
         const body = req.body as ChatCompletionRequest;
@@ -133,18 +136,28 @@ export class IFlowAPIServer {
         const isStream = body.stream === true;
         const model = body.model || getDefaultModel();
 
-        console.log(`流式: ${isStream}, 模型: ${model}`);
+        // 提取 system 和 user 消息
+        const { systemMessage, userMessage } = extractMessages(body.messages);
+        
+        if (!userMessage) {
+          return res.status(400).json(this.createError('未找到 user 消息', 'invalid_request_error'));
+        }
+
+        // 生成或使用已有的 conversation ID
+        // opencode 可能在 header 中传递，或者我们需要生成一个
+        let conversationId = req.headers['x-conversation-id'] as string | undefined;
+        if (!conversationId) {
+          // 从消息中生成一个稳定的 ID（基于 system + user 消息）
+          conversationId = `${Date.now()}-${Math.random().toString(36).substring(2, 10)}`;
+        }
 
-        // 转换消息为 iFlow 提示词
-        const prompt = messagesToIFlowPrompt(body.messages);
-        console.log('提示词:', prompt.substring(0, 100) + '...');
+        console.log(`会话: ${conversationId}, 流式: ${isStream}, 模型: ${model}`);
+        console.log(`系统消息: ${systemMessage ? '有' : '无'}, 用户消息: ${userMessage.substring(0, 50)}...`);
 
         if (isStream) {
-          console.log('处理流式响应...');
-          await this.handleStreamResponse(res, prompt, model);
+          await this.handleStreamResponse(res, conversationId, systemMessage, userMessage, model);
         } else {
-          console.log('处理非流式响应...');
-          await this.handleNonStreamResponse(res, prompt, model);
+          await this.handleNonStreamResponse(res, conversationId, systemMessage, userMessage, model);
         }
       } catch (error) {
         console.error('处理请求错误:', error);
@@ -156,18 +169,24 @@ export class IFlowAPIServer {
   /**
    * 处理流式响应
    */
-  private async handleStreamResponse(res: Response, prompt: string, model: string): Promise<void> {
+  private async handleStreamResponse(
+    res: Response,
+    conversationId: string,
+    systemMessage: string | undefined,
+    userMessage: string,
+    model: string
+  ): Promise<void> {
     const id = generateId();
 
     res.setHeader('Content-Type', 'text/event-stream');
     res.setHeader('Cache-Control', 'no-cache');
     res.setHeader('Connection', 'keep-alive');
 
-    // 设置 60 秒超时
+    // 设置 5 分钟超时
     const timeout = setTimeout(() => {
       res.write(formatSSE(this.createError('请求超时', 'timeout_error')));
       res.end();
-    }, 60000);
+    }, 300000);
 
     try {
       // 发送开始标记（角色）
@@ -187,7 +206,7 @@ export class IFlowAPIServer {
       // 流式发送内容
       let fullContent = '';
       let isDone = false;
-      for await (const chunk of this.adapter.sendMessageStream(prompt)) {
+      for await (const chunk of this.adapter.sendMessageStream(conversationId, systemMessage, userMessage)) {
         if (isDone) break;
 
         switch (chunk.type) {
@@ -205,7 +224,6 @@ export class IFlowAPIServer {
             break;
 
           case 'done':
-            // 收到完成信号，标记结束
             isDone = true;
             break;
 
@@ -238,19 +256,25 @@ export class IFlowAPIServer {
   /**
    * 处理非流式响应
    */
-  private async handleNonStreamResponse(res: Response, prompt: string, model: string): Promise<void> {
+  private async handleNonStreamResponse(
+    res: Response,
+    conversationId: string,
+    systemMessage: string | undefined,
+    userMessage: string,
+    model: string
+  ): Promise<void> {
     const id = generateId();
 
-    // 设置 60 秒超时
+    // 设置 5 分钟超时
     const timeout = setTimeout(() => {
       res.status(504).json(this.createError('请求超时', 'timeout_error'));
-    }, 60000);
+    }, 300000);
 
     try {
-      const response = await this.adapter.sendMessage(prompt);
+      const response = await this.adapter.sendMessage(conversationId, systemMessage, userMessage);
       clearTimeout(timeout);
 
-      const usage = calculateUsage(prompt, response.content);
+      const usage = calculateUsage(userMessage, response.content);
 
       const completionResponse = createCompletionResponse(
         id,
@@ -317,6 +341,7 @@ export class IFlowAPIServer {
         console.log(`\n🚀 iFlow API 桥接服务已启动`);
         console.log(`📍 服务地址: http://${host}:${port}`);
         console.log(`🤖 使用模型: ${model}`);
+        console.log(`💬 支持上下文管理: 是`);
         console.log(`🔗 OpenAI API: http://${host}:${port}/v1/chat/completions`);
         console.log(`📋 模型列表: http://${host}:${port}/v1/models`);
         console.log(`❤️  健康检查: http://${host}:${port}/health`);
@@ -338,4 +363,4 @@ export class IFlowAPIServer {
   async stop(): Promise<void> {
     await this.adapter.disconnect();
   }
-}
+}