@renxqoo/renx-code 0.0.9 → 0.0.12

package/vendor/agent-root/src/providers/adapters/anthropic.ts

@@ -1,572 +0,0 @@
-/**
- * Anthropic API Adapter
- *
- * Supports Anthropic Claude API specification:
- * - Separate system field (not a message role)
- * - Unique authentication headers (x-api-key + anthropic-version)
- * - Different response and streaming formats
- */
-
-import { BaseAPIAdapter } from './base';
-import type {
-  LLMRequest,
-  LLMResponse,
-  LLMRequestMessage,
-  LLMResponseMessage,
-  Chunk,
-  MessageContent,
-  ToolCall,
-} from '../types';
-import type { ProviderLogger } from '../types';
-
-/**
- * Anthropic content block
- */
-interface AnthropicContentBlock {
-  type: 'text' | 'image' | 'tool_use' | 'tool_result';
-  text?: string;
-  source?: {
-    type: 'base64' | 'url';
-    media_type?: string;
-    data?: string;
-    url?: string;
-  };
-  id?: string;
-  name?: string;
-  input?: Record<string, unknown>;
-  tool_use_id?: string;
-  content?: string | AnthropicContentBlock[];
-  is_error?: boolean;
-}
-
-/**
- * Anthropic request message format
- */
-interface AnthropicMessage {
-  role: 'user' | 'assistant';
-  content: string | AnthropicContentBlock[];
-}
-
-/**
- * Anthropic request body
- */
-interface AnthropicRequestBody {
-  model: string;
-  max_tokens: number;
-  system?: string;
-  messages: AnthropicMessage[];
-  stream?: boolean;
-  tools?: Array<{
-    name: string;
-    description: string;
-    input_schema: Record<string, unknown>;
-  }>;
-  temperature?: number;
-}
-
-/**
- * Anthropic response format
- */
-interface AnthropicResponse {
-  id: string;
-  type: 'message';
-  role: 'assistant';
-  content: AnthropicContentBlock[];
-  model: string;
-  stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | null;
-  stop_sequence: string | null;
-  usage: {
-    input_tokens: number;
-    output_tokens: number;
-    [key: string]: unknown;
-  };
-}
-
-/**
- * Anthropic stream event
- */
-interface AnthropicStreamEvent {
-  type: string;
-  message?: AnthropicResponse;
-  index?: number;
-  content_block?: AnthropicContentBlock;
-  delta?: {
-    type: string;
-    text?: string;
-    stop_reason?: string;
-    partial_json?: string;
-  };
-  usage?: {
-    input_tokens: number;
-    output_tokens: number;
-    [key: string]: unknown;
-  };
-}
-
-interface ToolCallStreamState {
-  id: string;
-  name: string;
-}
-
-/**
- * Anthropic API Adapter
- */
-export class AnthropicAdapter extends BaseAPIAdapter {
-  readonly endpointPath: string;
-  readonly defaultModel: string;
-  readonly apiVersion: string;
-  readonly logger?: ProviderLogger;
-
-  constructor(
-    options: {
-      endpointPath?: string;
-      defaultModel?: string;
-      apiVersion?: string;
-      logger?: ProviderLogger;
-    } = {}
-  ) {
-    super();
-    this.endpointPath = options.endpointPath ?? '/v1/messages';
-    this.defaultModel = options.defaultModel ?? 'claude-opus-4-6-20250528';
-    this.apiVersion = options.apiVersion ?? '2023-06-01';
-    this.logger = options.logger?.child('AnthropicAdapter');
-  }
-
-  /**
-   * Transform request to Anthropic format
-   */
-  transformRequest(options?: LLMRequest): LLMRequest {
-    if (!options) {
-      return { model: this.defaultModel, messages: [] };
-    }
-
-    const { messages, tools, ...rest } = options;
-
-    // Extract system messages
-    let systemPrompt = '';
-    const conversationMessages: LLMRequestMessage[] = [];
-
-    for (const msg of messages || []) {
-      if (msg.role === 'system') {
-        const content = this.extractTextContent(msg.content);
-        if (content) {
-          systemPrompt += (systemPrompt ? '\n\n' : '') + content;
-        }
-      } else {
-        conversationMessages.push(msg);
-      }
-    }
-    // Convert message format
-    const anthropicMessages = this.convertMessages(conversationMessages);
-
-    const body: AnthropicRequestBody = {
-      model: rest.model || this.defaultModel,
-      max_tokens: rest.max_tokens || 4096,
-      messages: anthropicMessages,
-      stream: rest.stream ?? false,
-    };
-    if (systemPrompt) {
-      body.system = systemPrompt;
-    }
-    if (rest.temperature !== undefined) {
-      body.temperature = rest.temperature;
-    }
-    // convert tool definitions
-    if (tools && tools.length > 0) {
-      body.tools = tools.map((tool) => ({
-        name: tool.function.name,
-        description: tool.function.description,
-        input_schema: tool.function.parameters,
-      }));
-    }
-    return body as unknown as LLMRequest;
-  }
-  /**
-   * Transform response to standard format
-   */
-  transformResponse(response: unknown): LLMResponse {
-    const anthropicResp = response as AnthropicResponse;
-    // extract text content and tool calls
-    const content: string[] = [];
-    const toolCalls: ToolCall[] = [];
-    for (const block of anthropicResp.content || []) {
-      if (block.type === 'text' && block.text) {
-        content.push(block.text);
-      } else if (block.type === 'tool_use' && block.id && block.name) {
-        toolCalls.push({
-          id: block.id,
-          type: 'function',
-          index: toolCalls.length,
-          function: {
-            name: block.name,
-            arguments: typeof block.input === 'string' ? block.input : JSON.stringify(block.input),
-          },
-        });
-      }
-    }
-    const message: LLMResponseMessage = {
-      role: 'assistant',
-      content: content.join(''),
-    };
-    if (toolCalls.length > 0) {
-      message.tool_calls = toolCalls;
-    }
-    // convert stop_reason
-    let finishReason: 'stop' | 'length' | 'tool_calls' | null = null;
-    if (anthropicResp.stop_reason === 'end_turn') {
-      finishReason = 'stop';
-    } else if (anthropicResp.stop_reason === 'max_tokens') {
-      finishReason = 'length';
-    } else if (anthropicResp.stop_reason === 'tool_use') {
-      finishReason = 'tool_calls';
-    }
-    return {
-      id: anthropicResp.id,
-      object: 'chat.completion',
-      created: Math.floor(Date.now() / 1000),
-      model: anthropicResp.model,
-      choices: [
-        {
-          index: 0,
-          message,
-          finish_reason: finishReason,
-        },
-      ],
-      usage: {
-        ...anthropicResp.usage,
-        prompt_tokens: anthropicResp.usage?.input_tokens || 0,
-        completion_tokens: anthropicResp.usage?.output_tokens || 0,
-        total_tokens:
-          (anthropicResp.usage?.input_tokens || 0) + (anthropicResp.usage?.output_tokens || 0),
-      },
-    };
-  }
-  /**
-   * Get request headers
-   */
-  getHeaders(apiKey: string): Headers {
-    return new Headers({
-      'Content-Type': 'application/json',
-      'x-api-key': apiKey,
-      'anthropic-version': this.apiVersion,
-    });
-  }
-  /**
-   * Get endpoint path
-   */
-  getEndpointPath(): string {
-    return this.endpointPath;
-  }
-  /**
-   * Parse Anthropic stream response
-   */
-  async *parseStreamAsync(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncGenerator<Chunk> {
-    const decoder = new TextDecoder();
-    let buffer = '';
-    const toolCallStates = new Map<number, ToolCallStreamState>();
-
-    const baseChunk: Partial<Chunk> = {};
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() ?? '';
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith('data:')) continue;
-          const data = trimmed.slice(5).trim();
-          if (!data) continue;
-          let event: AnthropicStreamEvent;
-          try {
-            event = JSON.parse(data);
-          } catch {
-            continue;
-          }
-          // update base chunk info
-          if (event.type === 'message_start' && event.message) {
-            baseChunk.id = event.message.id;
-            baseChunk.model = event.message.model;
-          }
-          // check if stream end
-          if (this.isStreamEndEvent(event)) {
-            return;
-          }
-          // parse event
-          const chunk = this.parseStreamEvent(event, baseChunk, toolCallStates);
-          if (chunk) {
-            yield chunk;
-          }
-        }
-      }
-    } finally {
-      try {
-        reader.releaseLock();
-      } catch {
-        // ignore lock release errors
-      }
-    }
-  }
-  /**
-   * Parse stream event to standard Chunk
-   */
-  parseStreamEvent(
-    event: AnthropicStreamEvent,
-    baseChunk: Partial<Chunk>,
-    toolCallStates?: Map<number, ToolCallStreamState>
-  ): Chunk | null {
-    switch (event.type) {
-      case 'message_start':
-        return {
-          id: event.message?.id || baseChunk.id || '',
-          index: 0,
-          model: event.message?.model || baseChunk.model || '',
-          object: 'chat.completion.chunk',
-          created: Math.floor(Date.now() / 1000),
-          choices: [
-            {
-              index: 0,
-              delta: { role: 'assistant', content: '' },
-              finish_reason: null,
-            },
-          ],
-        };
-      case 'content_block_start':
-        if (event.content_block?.type === 'tool_use') {
-          const toolIndex = event.index ?? 0;
-          const toolState: ToolCallStreamState = {
-            id: event.content_block.id || `tool_call_${toolIndex}`,
-            name: event.content_block.name || '',
-          };
-          toolCallStates?.set(toolIndex, toolState);
-
-          return {
-            ...baseChunk,
-            index: toolIndex,
-            choices: [
-              {
-                index: 0,
-                delta: {
-                  role: 'assistant',
-                  tool_calls: [
-                    {
-                      id: toolState.id,
-                      type: 'function',
-                      index: toolIndex,
-                      function: {
-                        name: toolState.name,
-                        arguments: '',
-                      },
-                    },
-                  ],
-                },
-                finish_reason: null,
-              },
-            ],
-          } as Chunk;
-        }
-        return null;
-      case 'content_block_delta':
-        if (event.delta?.type === 'text_delta' && event.delta.text) {
-          return {
-            ...baseChunk,
-            index: event.index ?? 0,
-            choices: [
-              {
-                index: 0,
-                delta: { role: 'assistant', content: event.delta.text },
-                finish_reason: null,
-              },
-            ],
-          } as Chunk;
-        } else if (event.delta?.type === 'input_json_delta' && event.delta.partial_json) {
-          const toolIndex = event.index ?? 0;
-          const toolState = toolCallStates?.get(toolIndex);
-          return {
-            ...baseChunk,
-            index: toolIndex,
-            choices: [
-              {
-                index: 0,
-                delta: {
-                  role: 'assistant',
-                  tool_calls: [
-                    {
-                      id: toolState?.id || `tool_call_${toolIndex}`,
-                      type: 'function',
-                      index: toolIndex,
-                      function: {
-                        name: toolState?.name || '',
-                        arguments: event.delta.partial_json,
-                      },
-                    },
-                  ],
-                },
-                finish_reason: null,
-              },
-            ],
-          } as Chunk;
-        }
-        return null;
-      case 'message_delta':
-        return {
-          ...baseChunk,
-          index: 0,
-          choices: [
-            {
-              index: 0,
-              delta: { role: 'assistant', content: '' },
-              finish_reason: this.convertStopReason(event.delta?.stop_reason),
-            },
-          ],
-          usage: event.usage
-            ? {
-                ...event.usage,
-                prompt_tokens: 0,
-                completion_tokens: event.usage.output_tokens || 0,
-                total_tokens: event.usage.output_tokens || 0,
-              }
-            : undefined,
-        } as Chunk;
-      case 'message_stop':
-        return null;
-      default:
-        return null;
-    }
-  }
-  /**
-   * Check if stream end event
-   */
-  isStreamEndEvent(event: AnthropicStreamEvent): boolean {
-    return event.type === 'message_stop';
-  }
-  /**
-   * Convert messages to Anthropic format
-   */
-  private convertMessages(messages: LLMRequestMessage[]): AnthropicMessage[] {
-    const result: AnthropicMessage[] = [];
-    for (const msg of messages) {
-      // handle tool response
-      if (msg.role === 'tool' && msg.tool_call_id) {
-        result.push({
-          role: 'user',
-          content: [
-            {
-              type: 'tool_result',
-              tool_use_id: msg.tool_call_id,
-              content: this.extractTextContent(msg.content),
-            },
-          ],
-        });
-        continue;
-      }
-      // handle assistant message with tool calls
-      const toolCalls = msg.tool_calls as ToolCall[] | undefined;
-      if (msg.role === 'assistant' && toolCalls && toolCalls.length > 0) {
-        const content: AnthropicContentBlock[] = [];
-        const textContent = this.extractTextContent(msg.content);
-        if (textContent) {
-          content.push({ type: 'text', text: textContent });
-        }
-        for (const toolCall of toolCalls) {
-          content.push({
-            type: 'tool_use',
-            id: toolCall.id,
-            name: toolCall.function.name,
-            input: this.parseJsonSafe(toolCall.function.arguments) || {},
-          });
-        }
-        result.push({ role: 'assistant', content });
-        continue;
-      }
-      // handle normal message
-      const content = this.convertContent(msg.content);
-      result.push({
-        role: msg.role as 'user' | 'assistant',
-        content,
-      });
-    }
-    return result;
-  }
-  /**
-   * Convert content to Anthropic format
-   */
-  private convertContent(content: MessageContent): string | AnthropicContentBlock[] {
-    if (typeof content === 'string') {
-      return content;
-    }
-    if (!Array.isArray(content)) {
-      return String(content);
-    }
-    const blocks: AnthropicContentBlock[] = [];
-    for (const part of content) {
-      if (part.type === 'text') {
-        blocks.push({ type: 'text', text: part.text });
-      } else if (part.type === 'image_url') {
-        const imageUrl = part.image_url.url;
-        if (imageUrl.startsWith('data:')) {
-          const matches = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
-          if (matches) {
-            blocks.push({
-              type: 'image',
-              source: {
-                type: 'base64',
-                media_type: matches[1],
-                data: matches[2],
-              },
-            });
-          }
-        } else {
-          this.logger?.warn('Anthropic does not support image URLs directly; expected base64 data');
-        }
-      }
-    }
-    return blocks.length === 1 && blocks[0].type === 'text' ? (blocks[0].text ?? '') : blocks;
-  }
-  /**
-   * Extract text content
-   */
-  private extractTextContent(content: MessageContent): string {
-    if (typeof content === 'string') {
-      return content;
-    }
-    if (Array.isArray(content)) {
-      return content
-        .filter((part): part is { type: 'text'; text: string } => part.type === 'text')
-        .map((part) => part.text)
-        .join('');
-    }
-    return '';
-  }
-  /**
-   * Safe JSON parse
-   */
-  private parseJsonSafe(str: string): Record<string, unknown> | null {
-    try {
-      return JSON.parse(str);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Convert stop_reason
-   */
-  private convertStopReason(
-    reason: string | undefined
-  ): 'stop' | 'length' | 'content_filter' | 'tool_calls' | null {
-    if (!reason) return null;
-    switch (reason) {
-      case 'end_turn':
-        return 'stop';
-      case 'max_tokens':
-        return 'length';
-      case 'tool_use':
-        return 'tool_calls';
-      default:
-        return null;
-    }
-  }
-}

package/vendor/agent-root/src/providers/adapters/base.ts

@@ -1,131 +0,0 @@
-/**
- * 基础 API 适配器
- *
- * API 适配器的抽象基类，用于处理特定于提供商的
- * 请求/响应转换。
- */
-
-import type {
-  InputContentPart,
-  LLMRequest,
-  LLMResponse,
-  LLMRequestMessage,
-  MessageContent,
-  Role,
-  Chunk,
-  ToolCall,
-} from '../types';
-
-export abstract class BaseAPIAdapter {
-  /**
-   * 将消息和选项转换为特定于提供商的请求体
-   */
-  abstract transformRequest(options?: LLMRequest): Record<string, unknown>;
-
-  /**
-   * 将特定于提供商的响应转换为标准格式
-   */
-  abstract transformResponse(response: unknown): LLMResponse;
-
-  /**
-   * 获取请求的 HTTP 头（包括身份验证）
-   */
-  abstract getHeaders(apiKey: string, config?: Record<string, unknown>): Headers;
-
-  /**
-   * 获取聊天补全的端点路径
-   * 例如：'/v1/chat/completions' 或 '/api/paas/v4/chat/completions'
-   */
-  abstract getEndpointPath(): string;
-
-  /**
-   * 可选：解析流式响应
-   * 子类可以覆盖此方法以支持非标准流式格式
-   * 如果返回 null，则使用默认的 OpenAI 流式解析器
-   */
-  parseStreamAsync?(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncGenerator<Chunk>;
-
-  /**
-   * 工具方法：检查清理后的消息是否应该发送
-   */
-  protected isMessageUsable(msg: {
-    role: string;
-    content?: unknown;
-    tool_call_id?: string;
-    tool_calls?: Array<{
-      id: string;
-      type: string;
-      function: { name: string; arguments: string };
-    }>;
-  }): boolean {
-    if (!msg) return false;
-    const hasContent =
-      msg.content !== undefined &&
-      msg.content !== null &&
-      (typeof msg.content !== 'string' || msg.content !== '') &&
-      (!Array.isArray(msg.content) || msg.content.length > 0);
-    const hasToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
-    const hasToolCallId = Boolean(msg.tool_call_id);
-    return hasContent || hasToolCalls || hasToolCallId;
-  }
-
-  /**
-   * 清理消息以用于 API 请求（移除内部字段）
-   */
-  protected cleanMessage(msg: Array<Record<string, unknown>>): LLMRequestMessage[] {
-    const cleaned: LLMRequestMessage[] = [];
-
-    for (const item of msg) {
-      const normalizedContent = this.normalizeMessageContent(item.content);
-      const message: LLMRequestMessage = {
-        content: normalizedContent,
-        role: item.role as Role,
-      };
-
-      if (item.reasoning_content !== undefined && item.reasoning_content !== null) {
-        message.reasoning_content = item.reasoning_content as string;
-      }
-
-      if (item.tool_call_id !== undefined && item.tool_call_id !== null) {
-        message.tool_call_id = item.tool_call_id as string;
-      }
-
-      if (item.tool_calls !== undefined && item.tool_calls !== null) {
-        message.tool_calls = item.tool_calls as ToolCall[];
-      }
-
-      cleaned.push(message);
-    }
-
-    return cleaned;
-  }
-
-  /**
-   * 标准化消息 content，保留 OpenAI 多模态数组结构
-   */
-  private normalizeMessageContent(content: unknown): MessageContent {
-    if (typeof content === 'string') return content;
-
-    if (Array.isArray(content)) {
-      return content.filter((part): part is InputContentPart => this.isValidContentPart(part));
-    }
-
-    if (content === undefined || content === null) {
-      return '';
-    }
-
-    return String(content);
-  }
-
-  private isValidContentPart(part: unknown): part is InputContentPart {
-    if (!part || typeof part !== 'object') return false;
-    const type = (part as { type?: unknown }).type;
-    return (
-      type === 'text' ||
-      type === 'image_url' ||
-      type === 'input_audio' ||
-      type === 'input_video' ||
-      type === 'file'
-    );
-  }
-}