@renxqoo/renx-code 0.0.9 → 0.0.12

package/vendor/agent-root/src/providers/__tests__/responses-adapter.test.ts

@@ -1,298 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ResponsesAdapter } from '../adapters/responses';
-import type { Chunk } from '../types';
-
-async function collectChunks(stream: AsyncGenerator<Chunk>): Promise<Chunk[]> {
-  const chunks: Chunk[] = [];
-  for await (const chunk of stream) {
-    chunks.push(chunk);
-  }
-  return chunks;
-}
-
-describe('ResponsesAdapter', () => {
-  it('should transform chat-style messages into responses input items', () => {
-    const adapter = new ResponsesAdapter({
-      defaultModel: 'gpt-5.3-codex',
-    });
-
-    const body = adapter.transformRequest({
-      model: 'gpt-5.3-codex',
-      stream: true,
-      max_tokens: 32,
-      temperature: 0.1,
-      model_reasoning_effort: 'high',
-      messages: [
-        { role: 'system', content: 'You are a helpful assistant.' },
-        { role: 'user', content: 'Reply with exactly: pong' },
-        {
-          role: 'assistant',
-          content: '',
-          tool_calls: [
-            {
-              id: 'call_1',
-              type: 'function',
-              index: 0,
-              function: {
-                name: 'lookup_weather',
-                arguments: '{"city":"Shanghai"}',
-              },
-            },
-          ],
-        },
-        {
-          role: 'tool',
-          tool_call_id: 'call_1',
-          content: '{"temperature":26}',
-        },
-      ],
-      tools: [
-        {
-          type: 'function',
-          function: {
-            name: 'lookup_weather',
-            description: 'Lookup weather by city',
-            parameters: {
-              type: 'object',
-              properties: {
-                city: { type: 'string' },
-              },
-              required: ['city'],
-            },
-          },
-        },
-      ],
-    });
-
-    expect(body).toMatchObject({
-      model: 'gpt-5.3-codex',
-      stream: true,
-      store: false,
-      max_output_tokens: 32,
-      reasoning: {
-        effort: 'high',
-      },
-      tools: [
-        {
-          type: 'function',
-          name: 'lookup_weather',
-          description: 'Lookup weather by city',
-        },
-      ],
-      input: [
-        {
-          role: 'system',
-          content: [{ type: 'input_text', text: 'You are a helpful assistant.' }],
-        },
-        {
-          role: 'user',
-          content: [{ type: 'input_text', text: 'Reply with exactly: pong' }],
-        },
-        {
-          type: 'function_call',
-          call_id: 'call_1',
-          name: 'lookup_weather',
-          arguments: '{"city":"Shanghai"}',
-        },
-        {
-          type: 'function_call_output',
-          call_id: 'call_1',
-          output: '{"temperature":26}',
-        },
-      ],
-    });
-
-    expect(body).not.toHaveProperty('stream_options');
-    expect(body).not.toHaveProperty('tool_stream');
-  });
-
-  it('should map assistant history content to gateway-compatible format', () => {
-    const adapter = new ResponsesAdapter({
-      defaultModel: 'gpt-5.3-codex',
-    });
-
-    const body = adapter.transformRequest({
-      model: 'gpt-5.3-codex',
-      stream: true,
-      max_tokens: 32,
-      messages: [
-        { role: 'system', content: 'You are a helpful assistant.' },
-        { role: 'user', content: '你好' },
-        { role: 'assistant', content: '你好！我在这儿，随时可以帮你看代码。' },
-        { role: 'user', content: '你是谁' },
-      ],
-    });
-
-    expect(body).toMatchObject({
-      input: [
-        {
-          role: 'system',
-          content: [{ type: 'input_text', text: 'You are a helpful assistant.' }],
-        },
-        {
-          role: 'user',
-          content: [{ type: 'input_text', text: '你好' }],
-        },
-        {
-          role: 'assistant',
-          content: '你好！我在这儿，随时可以帮你看代码。',
-        },
-        {
-          role: 'user',
-          content: [{ type: 'input_text', text: '你是谁' }],
-        },
-      ],
-    });
-  });
-
-  it('should transform responses output to standard response shape', () => {
-    const adapter = new ResponsesAdapter({
-      defaultModel: 'gpt-5.3-codex',
-    });
-
-    const response = adapter.transformResponse({
-      id: 'resp_123',
-      object: 'response',
-      created_at: 1_762_675_000,
-      model: 'gpt-5.3-codex',
-      output: [
-        { type: 'reasoning', content: [] },
-        {
-          type: 'message',
-          role: 'assistant',
-          content: [{ type: 'output_text', text: 'pong' }],
-        },
-      ],
-      usage: {
-        input_tokens: 10,
-        output_tokens: 2,
-        total_tokens: 12,
-        input_tokens_details: {
-          cached_tokens: 7,
-        },
-        output_tokens_details: {
-          reasoning_tokens: 1,
-        },
-      },
-    });
-
-    expect(response).toMatchObject({
-      id: 'resp_123',
-      object: 'chat.completion',
-      created: 1_762_675_000,
-      model: 'gpt-5.3-codex',
-      choices: [
-        {
-          index: 0,
-          message: {
-            role: 'assistant',
-            content: 'pong',
-          },
-          finish_reason: 'stop',
-        },
-      ],
-      usage: {
-        input_tokens: 10,
-        output_tokens: 2,
-        prompt_tokens: 10,
-        completion_tokens: 2,
-        total_tokens: 12,
-        input_tokens_details: {
-          cached_tokens: 7,
-        },
-        output_tokens_details: {
-          reasoning_tokens: 1,
-        },
-      },
-    });
-  });
-
-  it('should parse responses streaming events into standard chunks', async () => {
-    const adapter = new ResponsesAdapter({
-      defaultModel: 'gpt-5.3-codex',
-    });
-
-    const sse = [
-      'event: response.created\n',
-      'data: {"type":"response.created","response":{"id":"resp_123","model":"gpt-5.3-codex","created_at":1762675000}}\n\n',
-      'event: response.output_item.added\n',
-      'data: {"type":"response.output_item.added","output_index":0,"item":{"id":"fc_1","type":"function_call","call_id":"call_1","name":"lookup_weather","arguments":""}}\n\n',
-      'event: response.function_call_arguments.delta\n',
-      'data: {"type":"response.function_call_arguments.delta","output_index":0,"item_id":"fc_1","delta":"{\\"city\\":\\"Shanghai\\"}"}\n\n',
-      'event: response.output_text.delta\n',
-      'data: {"type":"response.output_text.delta","output_index":1,"content_index":0,"delta":"pong"}\n\n',
-      'event: response.completed\n',
-      'data: {"type":"response.completed","response":{"id":"resp_123","model":"gpt-5.3-codex","created_at":1762675000,"usage":{"input_tokens":10,"output_tokens":2,"total_tokens":12,"input_tokens_details":{"cached_tokens":6},"output_tokens_details":{"reasoning_tokens":1}}}}\n\n',
-    ].join('');
-
-    const stream = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode(sse));
-        controller.close();
-      },
-    });
-
-    const chunks = await collectChunks(adapter.parseStreamAsync!(stream.getReader()));
-
-    expect(chunks).toHaveLength(4);
-    expect(chunks[0].choices?.[0]?.delta.tool_calls?.[0]).toMatchObject({
-      id: 'call_1',
-      index: 0,
-      function: {
-        name: 'lookup_weather',
-        arguments: '',
-      },
-    });
-    expect(chunks[1].choices?.[0]?.delta.tool_calls?.[0]?.function?.arguments).toBe(
-      '{"city":"Shanghai"}'
-    );
-    expect(chunks[2].choices?.[0]?.delta.content).toBe('pong');
-    expect(chunks[3].usage).toMatchObject({
-      input_tokens: 10,
-      output_tokens: 2,
-      prompt_tokens: 10,
-      completion_tokens: 2,
-      total_tokens: 12,
-      input_tokens_details: {
-        cached_tokens: 6,
-      },
-      output_tokens_details: {
-        reasoning_tokens: 1,
-      },
-    });
-  });
-
-  it('should convert response.failed events into standard stream error chunks', async () => {
-    const adapter = new ResponsesAdapter({
-      defaultModel: 'glm-5',
-    });
-
-    const sse = [
-      'event: response.created\n',
-      'data: {"type":"response.created","response":{"id":"resp_failed","model":"glm-5","created_at":1762675000}}\n\n',
-      'event: response.failed\n',
-      'data: {"type":"response.failed","error":{"code":"upstream_timeout","type":"server_error","message":"temporary upstream timeout"}}\n\n',
-    ].join('');
-
-    const stream = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode(sse));
-        controller.close();
-      },
-    });
-
-    const chunks = await collectChunks(adapter.parseStreamAsync!(stream.getReader()));
-
-    expect(chunks).toEqual([
-      {
-        id: 'resp_failed',
-        index: 0,
-        error: {
-          code: 'upstream_timeout',
-          type: 'server_error',
-          message: 'temporary upstream timeout',
-        },
-      },
-    ]);
-  });
-});

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

@@ -1,354 +0,0 @@
-/**
- * AnthropicAdapter test cases
- *
- * Verify Anthropic API adapter functionality
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { AnthropicAdapter } from '../anthropic';
-import type { LLMRequestMessage, Tool } from '../../types';
-import { createLogger } from '../../../logger';
-import type { LogRecord } from '../../../logger';
-
-describe('AnthropicAdapter', () => {
-  let adapter: AnthropicAdapter;
-
-  beforeEach(() => {
-    adapter = new AnthropicAdapter({
-      defaultModel: 'claude-opus-4-6-20250528',
-      endpointPath: '/v1/messages',
-    });
-  });
-
-  describe('getEndpointPath', () => {
-    it('should return correct endpoint path', () => {
-      expect(adapter.getEndpointPath()).toBe('/v1/messages');
-    });
-  });
-
-  describe('getHeaders', () => {
-    it('should return correct Anthropic API headers', () => {
-      const headers = adapter.getHeaders('test-api-key');
-
-      expect(headers.get('Content-Type')).toBe('application/json');
-      expect(headers.get('x-api-key')).toBe('test-api-key');
-      expect(headers.get('anthropic-version')).toBe('2023-06-01');
-    });
-
-    it('should support custom API version', () => {
-      const customAdapter = new AnthropicAdapter({
-        apiVersion: '2024-01-01',
-      });
-      const headers = customAdapter.getHeaders('test-api-key');
-
-      expect(headers.get('anthropic-version')).toBe('2024-01-01');
-    });
-  });
-
-  describe('transformRequest', () => {
-    it('should correctly transform basic request', () => {
-      const messages: LLMRequestMessage[] = [{ role: 'user', content: 'Hello' }];
-
-      const request = adapter.transformRequest({
-        model: 'claude-opus-4-6-20250528',
-        messages,
-        max_tokens: 1024,
-      });
-
-      const body = request as unknown as Record<string, unknown>;
-      expect(body.model).toBe('claude-opus-4-6-20250528');
-      expect(body.max_tokens).toBe(1024);
-      expect(body.messages).toHaveLength(1);
-    });
-
-    it('should extract system message to top-level field', () => {
-      const messages: LLMRequestMessage[] = [
-        { role: 'system', content: 'You are a helpful assistant.' },
-        { role: 'user', content: 'Hello' },
-      ];
-
-      const request = adapter.transformRequest({
-        model: 'claude-opus-4-6-20250528',
-        messages,
-        max_tokens: 1024,
-      });
-
-      const body = request as unknown as Record<string, unknown>;
-      expect(body.system).toBe('You are a helpful assistant.');
-      expect(
-        (body.messages as Array<Record<string, unknown>>).find((m) => m.role === 'system')
-      ).toBeUndefined();
-    });
-
-    it('should merge multiple system messages', () => {
-      const messages: LLMRequestMessage[] = [
-        { role: 'system', content: 'You are helpful.' },
-        { role: 'system', content: 'Be concise.' },
-        { role: 'user', content: 'Hello' },
-      ];
-
-      const request = adapter.transformRequest({
-        model: 'claude-opus-4-6-20250528',
-        messages,
-        max_tokens: 1024,
-      });
-
-      const body = request as unknown as Record<string, unknown>;
-      expect(body.system).toBe('You are helpful.\n\nBe concise.');
-    });
-
-    it('should convert tool definitions into Anthropic format', () => {
-      const messages: LLMRequestMessage[] = [{ role: 'user', content: 'What is the weather?' }];
-      const tools: Tool[] = [
-        {
-          type: 'function',
-          function: {
-            name: 'get_weather',
-            description: 'Get weather info',
-            parameters: {
-              type: 'object',
-              properties: {
-                location: { type: 'string' },
-              },
-            },
-          },
-        },
-      ];
-
-      const request = adapter.transformRequest({
-        model: 'claude-opus-4-6-20250528',
-        messages,
-        max_tokens: 1024,
-        tools,
-      });
-
-      const body = request as unknown as Record<string, unknown>;
-      expect(body.tools).toBeDefined();
-      expect((body.tools as Array<Record<string, unknown>>)[0].name).toBe('get_weather');
-      expect((body.tools as Array<Record<string, unknown>>)[0].input_schema).toBeDefined();
-    });
-
-    it('should log warn when image_url is not base64 data URL', () => {
-      const records: LogRecord[] = [];
-      const logger = createLogger({
-        console: { enabled: false },
-        file: { enabled: false, filepath: './logs/test.log' },
-        onLog: (record) => {
-          records.push(record);
-        },
-      });
-      const warnSpy = vi.spyOn(logger, 'warn');
-      const adapterWithLogger = new AnthropicAdapter({ logger });
-
-      const messages: LLMRequestMessage[] = [
-        {
-          role: 'user',
-          content: [{ type: 'image_url', image_url: { url: 'https://example.com/demo.png' } }],
-        },
-      ];
-
-      adapterWithLogger.transformRequest({
-        model: 'claude-opus-4-6-20250528',
-        messages,
-        max_tokens: 1024,
-      });
-
-      expect(warnSpy).toHaveBeenCalledTimes(1);
-      expect(
-        records.some((record) => record.message.includes('Anthropic does not support image URLs'))
-      ).toBe(true);
-    });
-  });
-
-  describe('transformResponse', () => {
-    it('should correctly transform Anthropic response to standard format', () => {
-      const anthropicResponse = {
-        id: 'msg_xxx',
-        type: 'message',
-        role: 'assistant',
-        content: [{ type: 'text', text: 'Hello! How can I help you?' }],
-        model: 'claude-opus-4-6-20250528',
-        stop_reason: 'end_turn',
-        stop_sequence: null,
-        usage: {
-          input_tokens: 10,
-          output_tokens: 20,
-        },
-      };
-
-      const response = adapter.transformResponse(anthropicResponse);
-
-      expect(response.id).toBe('msg_xxx');
-      expect(response.model).toBe('claude-opus-4-6-20250528');
-      expect(response.choices).toHaveLength(1);
-      expect(response.choices[0].message.content).toBe('Hello! How can I help you?');
-      expect(response.choices[0].message.role).toBe('assistant');
-      expect(response.choices[0].finish_reason).toBe('stop');
-      expect(response.usage?.prompt_tokens).toBe(10);
-      expect(response.usage?.completion_tokens).toBe(20);
-    });
-
-    it('should correctly handle tool call response', () => {
-      const anthropicResponse = {
-        id: 'msg_xxx',
-        type: 'message',
-        role: 'assistant',
-        content: [
-          { type: 'text', text: '' },
-          {
-            type: 'tool_use',
-            id: 'toolu_xxx',
-            name: 'get_weather',
-            input: { location: 'Beijing' },
-          },
-        ],
-        model: 'claude-opus-4-6-20250528',
-        stop_reason: 'tool_use',
-        stop_sequence: null,
-        usage: {
-          input_tokens: 10,
-          output_tokens: 30,
-        },
-      };
-
-      const response = adapter.transformResponse(anthropicResponse);
-
-      expect(response.choices[0].message.tool_calls).toBeDefined();
-      expect(response.choices[0].message.tool_calls).toHaveLength(1);
-      expect(response.choices[0].message.tool_calls?.[0].id).toBe('toolu_xxx');
-      expect(response.choices[0].message.tool_calls?.[0].function.name).toBe('get_weather');
-      expect(response.choices[0].finish_reason).toBe('tool_calls');
-    });
-
-    it('should correctly convert stop_reason', () => {
-      const testCases = [
-        { stop_reason: 'end_turn', expected: 'stop' },
-        { stop_reason: 'max_tokens', expected: 'length' },
-        { stop_reason: 'tool_use', expected: 'tool_calls' },
-        { stop_reason: null, expected: null },
-      ];
-
-      for (const { stop_reason, expected } of testCases) {
-        const response = adapter.transformResponse({
-          id: 'msg_xxx',
-          type: 'message',
-          role: 'assistant',
-          content: [{ type: 'text', text: 'test' }],
-          model: 'claude-opus-4-6-20250528',
-          stop_reason,
-          stop_sequence: null,
-          usage: { input_tokens: 10, output_tokens: 5 },
-        });
-
-        expect(response.choices[0].finish_reason).toBe(expected);
-      }
-    });
-  });
-
-  describe('parseStreamEvent', () => {
-    it('should correctly parse message_start event', () => {
-      const event = {
-        type: 'message_start',
-        message: {
-          id: 'msg_xxx',
-          type: 'message' as const,
-          role: 'assistant' as const,
-          content: [] as Array<{ type: 'text'; text: string }>,
-          model: 'claude-opus-4-6-20250528',
-          stop_reason: null,
-          stop_sequence: null,
-          usage: { input_tokens: 10, output_tokens: 0 },
-        },
-      };
-
-      const chunk = adapter.parseStreamEvent(event, {});
-
-      expect(chunk).not.toBeNull();
-      expect(chunk?.id).toBe('msg_xxx');
-      expect(chunk?.model).toBe('claude-opus-4-6-20250528');
-      expect(chunk?.choices?.[0]?.delta.role).toBe('assistant');
-    });
-
-    it('should correctly parse content_block_delta text event', () => {
-      const event = {
-        type: 'content_block_delta',
-        index: 0,
-        delta: {
-          type: 'text_delta',
-          text: 'Hello',
-        },
-      };
-
-      const chunk = adapter.parseStreamEvent(event, {});
-
-      expect(chunk).not.toBeNull();
-      expect(chunk?.choices?.[0]?.delta.content).toBe('Hello');
-    });
-
-    it('should correctly parse message_delta event', () => {
-      const event = {
-        type: 'message_delta',
-        delta: {
-          type: 'stop_reason',
-          stop_reason: 'end_turn',
-        },
-        usage: {
-          input_tokens: 0,
-          output_tokens: 50,
-        },
-      };
-      const chunk = adapter.parseStreamEvent(event, {});
-
-      expect(chunk).not.toBeNull();
-      expect(chunk?.choices?.[0]?.finish_reason).toBe('stop');
-      expect(chunk?.usage?.completion_tokens).toBe(50);
-    });
-
-    it('should preserve tool call id and name across tool delta chunks', () => {
-      const states = new Map<number, { id: string; name: string }>();
-
-      const startChunk = adapter.parseStreamEvent(
-        {
-          type: 'content_block_start',
-          index: 2,
-          content_block: {
-            type: 'tool_use',
-            id: 'toolu_123',
-            name: 'get_weather',
-          },
-        },
-        {},
-        states
-      );
-
-      const deltaChunk = adapter.parseStreamEvent(
-        {
-          type: 'content_block_delta',
-          index: 2,
-          delta: {
-            type: 'input_json_delta',
-            partial_json: '{"location":"Beijing"}',
-          },
-        },
-        {},
-        states
-      );
-
-      expect(startChunk?.choices?.[0]?.delta.tool_calls?.[0].id).toBe('toolu_123');
-      expect(startChunk?.choices?.[0]?.delta.tool_calls?.[0].function.name).toBe('get_weather');
-      expect(deltaChunk?.choices?.[0]?.delta.tool_calls?.[0].id).toBe('toolu_123');
-      expect(deltaChunk?.choices?.[0]?.delta.tool_calls?.[0].function.name).toBe('get_weather');
-      expect(deltaChunk?.choices?.[0]?.delta.tool_calls?.[0].function.arguments).toBe(
-        '{"location":"Beijing"}'
-      );
-    });
-  });
-
-  describe('isStreamEndEvent', () => {
-    it('should correctly identify stream end event', () => {
-      expect(adapter.isStreamEndEvent({ type: 'message_stop' })).toBe(true);
-      expect(adapter.isStreamEndEvent({ type: 'message_start' })).toBe(false);
-      expect(adapter.isStreamEndEvent({ type: 'content_block_delta' })).toBe(false);
-    });
-  });
-});

package/vendor/agent-root/src/providers/adapters/__tests__/kimi.test.ts

@@ -1,58 +0,0 @@
-/**
- * Kimi Headers 测试用例
- *
- * 验证 Kimi API 请求头的正确性
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { KimiAdapter } from '../kimi';
-import { getKimiHeaders, getCommonHeaders, getUserAgent } from '../../kimi-headers';
-
-describe('KimiAdapter 请求头测试', () => {
-  let adapter: KimiAdapter;
-
-  beforeEach(() => {
-    adapter = new KimiAdapter();
-  });
-
-  it('应该在请求头中添加完整的 Kimi 平台标识', () => {
-    const headers = adapter.getHeaders('test-api-key');
-
-    // 核心认证头
-    expect(headers.get('Authorization')).toBe('Bearer test-api-key');
-    expect(headers.get('Content-Type')).toBe('application/json');
-
-    // Kimi 平台标识头
-    expect(headers.get('X-Msh-Platform')).toBe('kimi_cli');
-    expect(headers.get('X-Msh-Version')).toMatch(/^\d+\.\d+\.\d+$/);
-    expect(headers.get('X-Msh-Device-Name')).toBeTruthy();
-    expect(headers.get('X-Msh-Device-Model')).toBeTruthy();
-    expect(headers.get('X-Msh-Os-Version')).toBeTruthy();
-    expect(headers.get('X-Msh-Device-Id')).toMatch(/^[a-f0-9]{32}$/i);
-    expect(headers.get('User-Agent')).toBe(`KimiCLI/1.0.0`);
-  });
-});
-
-describe('kimi-headers 模块测试', () => {
-  it('getCommonHeaders 应该返回正确的平台标识', () => {
-    const headers = getCommonHeaders();
-
-    expect(headers['X-Msh-Platform']).toBe('kimi_cli');
-    expect(headers['X-Msh-Version']).toMatch(/^\d+\.\d+\.\d+$/);
-    expect(headers['X-Msh-Device-Name']).toBeTruthy();
-    expect(headers['X-Msh-Device-Model']).toBeTruthy();
-    expect(headers['X-Msh-Os-Version']).toBeTruthy();
-    expect(headers['X-Msh-Device-Id']).toMatch(/^[a-f0-9]{32}$/i);
-  });
-
-  it('getUserAgent 应该返回正确的 User-Agent', () => {
-    expect(getUserAgent()).toBe('KimiCLI/1.0.0');
-  });
-
-  it('getKimiHeaders 应该合并所有请求头', () => {
-    const headers = getKimiHeaders();
-
-    expect(headers['X-Msh-Platform']).toBe('kimi_cli');
-    expect(headers['User-Agent']).toBe(`KimiCLI/1.0.0`);
-  });
-});