@renxqoo/renx-code 0.0.8 → 0.0.10

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

@@ -1,289 +0,0 @@
-/**
- * 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

@@ -1,109 +0,0 @@
-/**
- * 流解析器工具
- *
- * 处理 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

@@ -1,76 +0,0 @@
-/**
- * Providers 统一导出
- */
-
-// Registry 相关
-export { Models, MODEL_CONFIGS, ProviderRegistry } from './registry';
-export type { ProviderType, BuiltinModelId, 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

@@ -1,177 +0,0 @@
-/**
- * 平台信息工具
- *
- * 用于获取客户端平台信息，生成请求头标识
- */
-
-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(),
-  };
-}