@renxqoo/renx-code 0.0.3 → 0.0.5

package/vendor/agent-root/src/providers/http/client.ts

@@ -0,0 +1,289 @@
+/**
+ * HTTP 客户端工具
+ *
+ * 提供统一的 HTTP 客户端，具有以下功能：
+ * - 单次请求执行（不包含重试）
+ * - Abort 信号支持（优先使用上层传入 signal）
+ * - 可选默认超时兜底（调用方未传 signal 时生效）
+ * - 与 LLM 错误类型集成的错误处理
+ *
+ * 超时控制设计：
+ * - Agent 层通过 LLMCaller 创建 AbortSignal.timeout() 控制主链路超时
+ * - 当调用方未传 signal 且配置了 defaultTimeoutMs，本层会创建兜底超时信号
+ * - 这样兼顾统一控制与 standalone 调用安全性
+ */
+
+import { LLMError, LLMAbortedError, LLMRetryableError, createErrorFromStatus } from '../types';
+import { classifyAbortReason } from '../types';
+import type { ProviderLogger } from '../types';
+
+export interface HttpClientOptions {
+  /** 日志器（推荐注入 Agent logger 的 child） */
+  logger?: ProviderLogger;
+  /** 默认超时（毫秒，仅在调用方未传 signal 时生效） */
+  defaultTimeoutMs?: number;
+}
+
+export type RequestInitWithOptions = RequestInit;
+
+/**
+ * HTTP 客户端
+ *
+ * 超时优先由调用方通过 options.signal 传入；
+ * 如未传入且配置了 defaultTimeoutMs，会自动应用默认超时信号。
+ */
+export class HTTPClient {
+  readonly logger?: ProviderLogger;
+  readonly defaultTimeoutMs?: number;
+
+  constructor(options: HttpClientOptions = {}) {
+    this.logger = options.logger?.child('HTTPClient');
+    this.defaultTimeoutMs = this.normalizeTimeoutMs(options.defaultTimeoutMs);
+  }
+
+  /**
+   * 单次 Fetch（重试由上层 Agent 负责）
+   *
+   * @param url - 请求 URL
+   * @param options - 请求选项，signal 应已包含超时逻辑
+   */
+  async fetch(url: string, options: RequestInitWithOptions = {}): Promise<Response> {
+    const requestOptions = this.applyDefaultSignal(options);
+    try {
+      const response = await this.executeFetch(url, requestOptions);
+
+      // 检查 HTTP 错误
+      if (!response.ok) {
+        const errorText = await response.text();
+        // 提取 Retry-After 响应头（用于 429 等错误）
+        const retryAfterMs = this.extractRetryAfterMs(response);
+        throw createErrorFromStatus(response.status, response.statusText, errorText, retryAfterMs);
+      }
+
+      return response;
+    } catch (rawError) {
+      throw this.normalizeError(rawError, requestOptions.signal ?? undefined);
+    }
+  }
+
+  /**
+   * 执行 Fetch 请求
+   *
+   * 直接使用传入的 signal，不创建额外的超时信号
+   */
+  private async executeFetch(url: string, options: RequestInit): Promise<Response> {
+    const upstreamSignal = options.signal;
+    const method = options.method || 'GET';
+
+    try {
+      this.logger?.debug('Sending request', {
+        method,
+        url,
+        hasSignal: Boolean(upstreamSignal),
+        header: JSON.stringify(options),
+      });
+
+      const response = await fetch(url, {
+        ...options,
+        signal: upstreamSignal,
+      });
+
+      this.logger?.debug('Response received', {
+        method,
+        url,
+        status: response.status,
+      });
+
+      return response;
+    } catch (error) {
+      this.logger?.warn(
+        'Request failed',
+        {
+          method,
+          url,
+          aborted: Boolean(upstreamSignal?.aborted),
+        },
+        error
+      );
+
+      // 检查是否为超时或中止错误
+      if (upstreamSignal?.aborted) {
+        const reason = this.getAbortReason(upstreamSignal);
+        if (reason === 'timeout') {
+          throw new LLMRetryableError('Request timeout', undefined, 'TIMEOUT');
+        }
+        throw new LLMAbortedError('Request was cancelled by upstream signal');
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * 获取 AbortSignal 的中止原因
+   */
+  private getAbortReason(signal: AbortSignal): 'timeout' | 'abort' | 'unknown' {
+    try {
+      const reason = classifyAbortReason(signal.reason);
+      if (reason === 'idle_timeout' || reason === 'timeout') {
+        return 'timeout';
+      }
+      if (reason === 'abort') {
+        return 'abort';
+      }
+    } catch {
+      // 忽略访问 reason 的错误
+    }
+    return 'unknown';
+  }
+
+  /**
+   * 从响应头中提取 Retry-After 值（毫秒）
+   *
+   * Retry-After 可以是秒数或日期字符串
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+   */
+  private extractRetryAfterMs(response: Response): number | undefined {
+    const retryAfterMsHeader = response.headers.get('retry-after-ms');
+    if (retryAfterMsHeader) {
+      const ms = Number(retryAfterMsHeader);
+      if (Number.isFinite(ms) && ms > 0) {
+        return ms;
+      }
+    }
+
+    const retryAfter = response.headers.get('Retry-After');
+    if (!retryAfter) {
+      return undefined;
+    }
+
+    // 尝试解析为秒数（支持小数，避免精度损失）
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return Math.ceil(seconds * 1000);
+    }
+
+    // 尝试解析为日期字符串
+    const dateMs = Date.parse(retryAfter);
+    if (Number.isFinite(dateMs)) {
+      const diffMs = dateMs - Date.now();
+      if (diffMs > 0) {
+        return Math.ceil(diffMs);
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * 归一化错误
+   */
+  private normalizeError(error: unknown, signal?: AbortSignal): Error {
+    // 已经是 LLM 错误，直接返回
+    if (error instanceof LLMError) {
+      return error;
+    }
+
+    // 检查中止信号
+    if (signal?.aborted) {
+      const reason = this.getAbortReason(signal);
+      if (reason === 'timeout') {
+        return new LLMRetryableError('Request timeout', undefined, 'TIMEOUT');
+      }
+      return new LLMAbortedError('Request was cancelled');
+    }
+
+    // Body 超时类错误
+    if (this.isBodyTimeoutLikeError(error)) {
+      return new LLMRetryableError('Response body timeout', undefined, 'BODY_TIMEOUT');
+    }
+
+    // 网络类错误
+    if (this.isNetworkLikeError(error)) {
+      const message = error instanceof Error ? error.message : String(error);
+      return new LLMRetryableError(
+        `Network request failed: ${message}`,
+        undefined,
+        'NETWORK_ERROR'
+      );
+    }
+
+    if (error instanceof Error) {
+      return error;
+    }
+
+    return new LLMError(String(error));
+  }
+
+  private isBodyTimeoutLikeError(error: unknown): boolean {
+    if (!(error instanceof Error)) return false;
+
+    const code = this.getErrorCode(error);
+    const message = `${error.name} ${error.message}`.toLowerCase();
+
+    return (
+      code === 'UND_ERR_BODY_TIMEOUT' ||
+      message.includes('body timeout') ||
+      message.includes('terminated')
+    );
+  }
+
+  private isNetworkLikeError(error: unknown): boolean {
+    if (!(error instanceof Error)) return false;
+
+    const code = this.getErrorCode(error);
+    const message = `${error.name} ${error.message}`.toLowerCase();
+    if (!code) {
+      // Bun/Node fetch 的网络失败既可能是 TypeError，也可能是普通 Error 文案
+      return (
+        error instanceof TypeError ||
+        message.includes('unable to connect') ||
+        message.includes('access the url') ||
+        message.includes('failed to fetch') ||
+        message.includes('fetch failed') ||
+        message.includes('network request failed')
+      );
+    }
+
+    return [
+      'ECONNRESET',
+      'ECONNREFUSED',
+      'ENOTFOUND',
+      'EAI_AGAIN',
+      'ETIMEDOUT',
+      'UND_ERR_SOCKET',
+      'UND_ERR_CONNECT_TIMEOUT',
+      'UND_ERR_HEADERS_TIMEOUT',
+      'UND_ERR_ABORTED',
+    ].includes(code);
+  }
+
+  private getErrorCode(error: Error): string | undefined {
+    const withCode = error as Error & { code?: unknown; cause?: unknown };
+    if (typeof withCode.code === 'string') {
+      return withCode.code;
+    }
+    const cause = withCode.cause as { code?: unknown } | undefined;
+    if (cause && typeof cause.code === 'string') {
+      return cause.code;
+    }
+    return undefined;
+  }
+
+  private applyDefaultSignal(options: RequestInitWithOptions): RequestInitWithOptions {
+    if (options.signal || !this.defaultTimeoutMs) {
+      return options;
+    }
+    return {
+      ...options,
+      signal: AbortSignal.timeout(this.defaultTimeoutMs),
+    };
+  }
+
+  private normalizeTimeoutMs(value: number | undefined): number | undefined {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+      return undefined;
+    }
+    return value;
+  }
+}

package/vendor/agent-root/src/providers/http/stream-parser.ts

@@ -0,0 +1,109 @@
+/**
+ * 流解析器工具
+ *
+ * 处理 SSE（服务器发送事件）流解析，用于 LLM 流式响应。
+ */
+
+import type { Chunk } from '../types';
+
+/**
+ * SSE（服务器发送事件）的流解析器
+ */
+export class StreamParser {
+  /**
+   * 解析 SSE 行并提取数据
+   * 对于空行、注释或非数据行返回 null
+   */
+  static parseSseLine(line: string): string | null {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith(':')) {
+      return null;
+    }
+    if (trimmed.startsWith('data:')) {
+      return trimmed.slice(5).trim();
+    }
+    if (trimmed.startsWith('{')) {
+      return trimmed;
+    }
+    return null;
+  }
+
+  /**
+   * 检查数据是否指示流结束
+   */
+  static isStreamEnd(data: string): boolean {
+    return data === '[DONE]';
+  }
+
+  /**
+   * 安全地解析 JSON，失败时返回 null
+   */
+  static safeJsonParse<T>(data: string): T | null {
+    try {
+      return JSON.parse(data) as T;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 处理可读流并返回 AsyncGenerator
+   *
+   * 注意：使用 try/finally 确保在生成器被提前终止时（如 break 或 return）
+   * reader 能够被正确释放，避免流锁定问题
+   *
+   * @param reader - 可读流读取器
+   * @returns 异步生成器，每次 yield 一个 chunk
+   */
+  static async *parseAsync(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncGenerator<Chunk> {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let shouldStop = false;
+
+    try {
+      while (!shouldStop) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          // 处理流结束时剩余的缓冲区
+          if (buffer.trim()) {
+            const data = this.parseSseLine(buffer);
+            if (data && !this.isStreamEnd(data)) {
+              const chunk = this.safeJsonParse<Chunk>(data);
+              if (chunk) yield chunk;
+            }
+          }
+          break;
+        }
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/[\r\n]+/);
+        buffer = lines.pop() ?? '';
+
+        for (const line of lines) {
+          const data = this.parseSseLine(line);
+
+          if (!data) continue;
+
+          if (this.isStreamEnd(data)) {
+            shouldStop = true;
+            break;
+          }
+
+          const chunk = this.safeJsonParse<Chunk>(data);
+          if (!chunk) continue;
+
+          yield chunk;
+        }
+      }
+    } finally {
+      // 确保在生成器结束时释放 reader 锁
+      // 这样即使消费者提前 break，也不会导致流被锁定
+      try {
+        reader.releaseLock();
+      } catch {
+        // 忽略释放锁时的错误（如流已关闭）
+      }
+    }
+  }
+}

package/vendor/agent-root/src/providers/index.ts

@@ -0,0 +1,76 @@
+/**
+ * Providers 统一导出
+ */
+
+// Registry 相关
+export { Models, MODEL_CONFIGS, ProviderRegistry } from './registry';
+export type { ProviderType, ModelId } from './registry';
+
+// Provider 相关
+export { LLMProvider } from './types';
+export type { BaseProviderConfig, ProviderLogger } from './types';
+
+// OpenAI Compatible Provider
+export { OpenAICompatibleProvider } from './openai-compatible';
+export type { OpenAICompatibleConfig } from './openai-compatible';
+
+// 适配器
+export { BaseAPIAdapter } from './adapters/base';
+export { StandardAdapter, type StandardTransformOptions } from './adapters/standard';
+
+// HTTP 客户端
+export { HTTPClient, type HttpClientOptions, type RequestInitWithOptions } from './http/client';
+export { StreamParser } from './http/stream-parser';
+
+// 错误类型
+export {
+  PERMANENT_STREAM_ERROR_CODE_MARKERS,
+  PERMANENT_STREAM_ERROR_MESSAGE_PATTERNS,
+  isPermanentStreamChunkError,
+  abortReasonToText,
+  isIdleTimeoutReasonText,
+  isTimeoutReasonText,
+  classifyAbortReason,
+  LLMError,
+  LLMRetryableError,
+  LLMRateLimitError,
+  LLMPermanentError,
+  LLMAuthError,
+  LLMNotFoundError,
+  LLMBadRequestError,
+  LLMAbortedError,
+  createErrorFromStatus,
+  isRetryableError,
+  isPermanentError,
+  isAbortedError,
+  calculateBackoff,
+  DEFAULT_BACKOFF_CONFIG,
+} from './types';
+
+export type { BackoffConfig } from './types';
+
+// 类型定义
+export type {
+  ToolCall,
+  Role,
+  TextContentPart,
+  ImageUrlContentPart,
+  InputAudioContentPart,
+  InputVideoContentPart,
+  FileContentPart,
+  InputContentPart,
+  MessageContent,
+  Usage,
+  StreamOptions,
+  BaseLLMMessage,
+  LLMRequestMessage,
+  FinishReason,
+  LLMResponse,
+  StreamChunkError,
+  Chunk,
+  StreamCallback,
+  Tool,
+  LLMGenerateOptions,
+  LLMRequest,
+  AnthropicStreamEvent,
+} from './types';

package/vendor/agent-root/src/providers/kimi-headers.ts

@@ -0,0 +1,177 @@
+/**
+ * 平台信息工具
+ *
+ * 用于获取客户端平台信息，生成请求头标识
+ */
+
+import * as os from 'os';
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash } from 'crypto';
+
+// 从 package.json 读取版本号
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+
+const PACKAGE_VERSION = (() => {
+  try {
+    // ESM 环境获取 package.json 路径
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageJsonPath = path.resolve(currentDir, '../../package.json');
+    const content = readFileSync(packageJsonPath, 'utf-8');
+    const pkg = JSON.parse(content);
+    return pkg.version || '1.0.0';
+  } catch {
+    return '1.0.0';
+  }
+})();
+
+/**
+ * 获取设备唯一 ID
+ *
+ * 优先从缓存文件读取，不存在则生成新的并保存
+ */
+function getDeviceId(): string {
+  const cacheDir = path.join(os.homedir(), '.renx');
+  const deviceIdPath = path.join(cacheDir, 'device_id');
+
+  try {
+    // 尝试读取已存在的设备 ID
+    if (fs.existsSync(deviceIdPath)) {
+      const id = fs.readFileSync(deviceIdPath, 'utf-8').trim();
+      if (id && /^[a-f0-9]{32}$/i.test(id)) {
+        return id;
+      }
+    }
+
+    // 生成新的设备 ID
+    const id = createHash('md5')
+      .update(`${os.hostname()}-${os.userInfo().username}-${Date.now()}-${Math.random()}`)
+      .digest('hex');
+
+    // 确保目录存在
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
+    }
+
+    // 保存设备 ID（权限 600）
+    fs.writeFileSync(deviceIdPath, id, { mode: 0o600 });
+    return id;
+  } catch {
+    // 生成临时 ID（不持久化）
+    return createHash('md5').update(`${os.hostname()}-${os.userInfo().username}`).digest('hex');
+  }
+}
+
+/**
+ * 获取设备型号
+ */
+function getDeviceModel(): string {
+  const platform = os.platform();
+  const arch = os.arch();
+  const release = os.release();
+
+  switch (platform) {
+    case 'darwin': {
+      const version = release.split('.')[0];
+      const macVersion = getMacOSVersion(version);
+      return `macOS ${macVersion} ${arch}`;
+    }
+    case 'win32': {
+      const releaseNum = os.release();
+      let windowsVersion = releaseNum;
+      // Windows 10 build >= 22000 是 Windows 11
+      try {
+        const build = parseInt(releaseNum.split('.')[2] || '0', 10);
+        if (build >= 22000) {
+          windowsVersion = '11';
+        } else {
+          windowsVersion = '10';
+        }
+      } catch {
+        // 忽略解析错误
+      }
+      return `Windows ${windowsVersion} ${arch}`;
+    }
+    case 'linux': {
+      return `Linux ${release} ${arch}`;
+    }
+    default:
+      return `${platform} ${release} ${arch}`;
+  }
+}
+
+/**
+ * 获取 macOS 版本号
+ */
+function getMacOSVersion(darwinVersion: string): string {
+  const major = parseInt(darwinVersion, 10);
+  // Darwin 版本到 macOS 版本的映射
+  const versionMap: Record<number, string> = {
+    23: '14.0', // Sonoma
+    22: '13.0', // Ventura
+    21: '12.0', // Monterey
+    20: '11.0', // Big Sur
+  };
+  return versionMap[major] || `${major}.0`;
+}
+
+/**
+ * ASCII 化头部值（移除非 ASCII 字符）
+ */
+function asciiHeaderValue(value: string, fallback = 'unknown'): string {
+  try {
+    // 检查是否为纯 ASCII
+    if (/^[\x20-\x7E]*$/.test(value)) {
+      return value;
+    }
+    // 移除非 ASCII 字符
+    const sanitized = value.replace(/[^\x20-\x7E]/g, '').trim();
+    return sanitized || fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+// 缓存设备 ID（避免重复 I/O）
+let cachedDeviceId: string | null = null;
+
+/**
+ * 获取公共请求头
+ *
+ * 用于 Kimi API 请求的客户端标识
+ */
+export function getCommonHeaders(): Record<string, string> {
+  const deviceId = cachedDeviceId || (cachedDeviceId = getDeviceId());
+  const deviceName = os.hostname() || 'unknown';
+  const deviceModel = getDeviceModel();
+  const osVersion = os.release();
+  const version = PACKAGE_VERSION;
+
+  return {
+    'X-Msh-Platform': 'kimi_cli',
+    'X-Msh-Version': asciiHeaderValue(version),
+    'X-Msh-Device-Name': asciiHeaderValue(deviceName),
+    'X-Msh-Device-Model': asciiHeaderValue(deviceModel),
+    'X-Msh-Os-Version': asciiHeaderValue(osVersion),
+    'X-Msh-Device-Id': deviceId,
+  };
+}
+
+/**
+ * 获取 User-Agent
+ */
+export function getUserAgent(): string {
+  // return 'claude-cli/2.1.19 (external, cli)';
+  return `KimiCLI/${PACKAGE_VERSION}`;
+}
+
+/**
+ * 获取完整的 Kimi 请求头
+ */
+export function getKimiHeaders(): Record<string, string> {
+  return {
+    ...getCommonHeaders(),
+    'User-Agent': getUserAgent(),
+  };
+}