@renxqoo/renx-code 0.0.4 → 0.0.5

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

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

@@ -0,0 +1,131 @@
+/**
+ * 基础 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'
+    );
+  }
+}