@renxqoo/renx-code 0.0.3 → 0.0.5

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

@@ -0,0 +1,298 @@
+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

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

@@ -0,0 +1,58 @@
+/**
+ * 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`);
+  });
+});