@renxqoo/renx-code 0.0.8 → 0.0.10

package/vendor/agent-root/src/agent/agent/__test__/logger.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createAgentLoggerAdapter } from '../logger';
-
-describe('agent/logger adapter', () => {
-  it('maps AgentLogger calls to core structured logger with merged context', () => {
-    const core = {
-      debug: vi.fn(),
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-    };
-
-    const logger = createAgentLoggerAdapter(core, { service: 'renx' });
-    logger.info?.('run.start', { executionId: 'exec_1', stepIndex: 1 }, { extra: true });
-    logger.error?.('run.error', new Error('boom'), { executionId: 'exec_1' });
-
-    expect(core.info).toHaveBeenCalledWith(
-      'run.start',
-      expect.objectContaining({
-        service: 'renx',
-        executionId: 'exec_1',
-        stepIndex: 1,
-      }),
-      { extra: true }
-    );
-    expect(core.error).toHaveBeenCalledWith(
-      'run.error',
-      expect.any(Error),
-      expect.objectContaining({
-        service: 'renx',
-        executionId: 'exec_1',
-      })
-    );
-  });
-});

package/vendor/agent-root/src/agent/agent/__test__/message-utils.test.ts

@@ -1,517 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  convertMessageToLLMMessage,
-  mergeLLMConfig,
-  shouldSendMessageToLLM,
-} from '../message-utils';
-import type { Message } from '../../types';
-
-const createMessage = (overrides: Partial<Message> = {}): Message => ({
-  messageId: 'msg_1',
-  type: 'user',
-  role: 'user',
-  content: '',
-  timestamp: Date.now(),
-  ...overrides,
-});
-
-describe('shouldSendMessageToLLM', () => {
-  it('filters empty assistant-text messages with no reasoning or tool calls', () => {
-    const message = createMessage({
-      role: 'assistant',
-      type: 'assistant-text',
-      content: '',
-      reasoning_content: '',
-      tool_calls: undefined,
-    });
-
-    expect(shouldSendMessageToLLM(message)).toBe(false);
-  });
-
-  it('keeps assistant-text messages with text content', () => {
-    const message = createMessage({
-      role: 'assistant',
-      type: 'assistant-text',
-      content: 'answer',
-      reasoning_content: '',
-    });
-
-    expect(shouldSendMessageToLLM(message)).toBe(true);
-  });
-
-  it('keeps assistant-text messages with reasoning content', () => {
-    const message = createMessage({
-      role: 'assistant',
-      type: 'assistant-text',
-      content: '',
-      reasoning_content: 'thinking',
-    });
-
-    expect(shouldSendMessageToLLM(message)).toBe(true);
-  });
-
-  it('keeps non-assistant messages even when content is empty', () => {
-    const message = createMessage({
-      role: 'tool',
-      type: 'tool-result',
-      content: '',
-      tool_call_id: 'call_1',
-    });
-
-    expect(shouldSendMessageToLLM(message)).toBe(true);
-  });
-});
-
-describe('convertMessageToLLMMessage', () => {
-  it('converts basic message', () => {
-    const message = createMessage({
-      role: 'user',
-      content: 'Hello',
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.role).toBe('user');
-    expect(result.content).toBe('Hello');
-  });
-
-  it('converts message with tool_call_id', () => {
-    const message = createMessage({
-      role: 'tool',
-      content: 'Tool result',
-      tool_call_id: 'call_123',
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.role).toBe('tool');
-    expect(result.content).toBe('Tool result');
-    expect(result.tool_call_id).toBe('call_123');
-  });
-
-  it('converts message with id', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: 'Response',
-      id: 'msg_123',
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.id).toBe('msg_123');
-  });
-
-  it('converts message with reasoning_content', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: 'Response',
-      reasoning_content: 'Thinking...',
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.reasoning_content).toBe('Thinking...');
-  });
-
-  it('converts message with valid tool_calls', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test',
-            arguments: '{"key": "value"}',
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls).toHaveLength(1);
-    expect(result.tool_calls![0].function.arguments).toBe('{"key": "value"}');
-  });
-
-  it('sanitizes invalid tool_calls arguments', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test',
-            arguments: 'invalid json',
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls).toHaveLength(1);
-    expect(result.tool_calls![0].function.arguments).toBe('{}');
-  });
-
-  it('sanitizes empty tool_calls arguments', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test',
-            arguments: '',
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls![0].function.arguments).toBe('{}');
-  });
-
-  it('sanitizes whitespace-only tool_calls arguments', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test',
-            arguments: '   ',
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls![0].function.arguments).toBe('{}');
-  });
-
-  it('handles non-string tool_calls arguments', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test',
-            arguments: 123 as any,
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls![0].function.arguments).toBe('{}');
-  });
-
-  it('handles null tool_calls arguments', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test',
-            arguments: null as any,
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls![0].function.arguments).toBe('{}');
-  });
-
-  it('handles undefined tool_calls arguments', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test',
-            arguments: undefined as any,
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls![0].function.arguments).toBe('{}');
-  });
-
-  it('handles empty tool_calls array', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls).toEqual([]);
-  });
-
-  it('handles null tool_calls', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: null as any,
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls).toBeNull();
-  });
-
-  it('handles undefined tool_calls', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: undefined,
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls).toBeUndefined();
-  });
-
-  it('handles multiple tool_calls', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test1',
-            arguments: '{"key1": "value1"}',
-          },
-        },
-        {
-          id: 'call_2',
-          type: 'function',
-          index: 1,
-          function: {
-            name: 'test2',
-            arguments: 'invalid',
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls).toHaveLength(2);
-    expect(result.tool_calls![0].function.arguments).toBe('{"key1": "value1"}');
-    expect(result.tool_calls![1].function.arguments).toBe('{}');
-  });
-
-  it('preserves tool_call properties', () => {
-    const message = createMessage({
-      role: 'assistant',
-      content: '',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          index: 0,
-          function: {
-            name: 'test',
-            arguments: '{}',
-          },
-        },
-      ],
-    });
-
-    const result = convertMessageToLLMMessage(message);
-
-    expect(result.tool_calls![0].id).toBe('call_1');
-    expect(result.tool_calls![0].type).toBe('function');
-    expect(result.tool_calls![0].index).toBe(0);
-    expect(result.tool_calls![0].function.name).toBe('test');
-  });
-});
-
-describe('mergeLLMConfig', () => {
-  it('returns undefined when all inputs are undefined', () => {
-    const result = mergeLLMConfig(undefined, undefined, undefined);
-    expect(result).toBeUndefined();
-  });
-
-  it('returns config when only config is provided', () => {
-    const config = { model: 'gpt-4', temperature: 0.7 };
-    const result = mergeLLMConfig(config, undefined, undefined);
-
-    expect(result).toEqual(config);
-  });
-
-  it('adds tools to config', () => {
-    const config = { model: 'gpt-4' };
-    const tools = [
-      {
-        type: 'function' as const,
-        function: { name: 'test', description: 'Test', parameters: {} },
-      },
-    ];
-    const result = mergeLLMConfig(config, tools, undefined);
-
-    expect(result).toEqual({
-      model: 'gpt-4',
-      tools,
-    });
-  });
-
-  it('adds abortSignal to config', () => {
-    const config = { model: 'gpt-4' };
-    const abortSignal = new AbortController().signal;
-    const result = mergeLLMConfig(config, undefined, abortSignal);
-
-    expect(result).toEqual({
-      model: 'gpt-4',
-      abortSignal,
-    });
-  });
-
-  it('adds both tools and abortSignal to config', () => {
-    const config = { model: 'gpt-4' };
-    const tools = [
-      {
-        type: 'function' as const,
-        function: { name: 'test', description: 'Test', parameters: {} },
-      },
-    ];
-    const abortSignal = new AbortController().signal;
-    const result = mergeLLMConfig(config, tools, abortSignal);
-
-    expect(result).toEqual({
-      model: 'gpt-4',
-      tools,
-      abortSignal,
-    });
-  });
-
-  it('handles empty tools array', () => {
-    const config = { model: 'gpt-4' };
-    const result = mergeLLMConfig(config, [], undefined);
-
-    expect(result).toEqual({ model: 'gpt-4' });
-  });
-
-  it('handles null config', () => {
-    const tools = [
-      {
-        type: 'function' as const,
-        function: { name: 'test', description: 'Test', parameters: {} },
-      },
-    ];
-    const result = mergeLLMConfig(null as any, tools, undefined);
-
-    expect(result).toEqual({ tools });
-  });
-
-  it('handles undefined config with tools', () => {
-    const tools = [
-      {
-        type: 'function' as const,
-        function: { name: 'test', description: 'Test', parameters: {} },
-      },
-    ];
-    const result = mergeLLMConfig(undefined, tools, undefined);
-
-    expect(result).toEqual({ tools });
-  });
-
-  it('handles undefined config with abortSignal', () => {
-    const abortSignal = new AbortController().signal;
-    const result = mergeLLMConfig(undefined, undefined, abortSignal);
-
-    expect(result).toEqual({ abortSignal });
-  });
-
-  it('handles undefined config with both tools and abortSignal', () => {
-    const tools = [
-      {
-        type: 'function' as const,
-        function: { name: 'test', description: 'Test', parameters: {} },
-      },
-    ];
-    const abortSignal = new AbortController().signal;
-    const result = mergeLLMConfig(undefined, tools, abortSignal);
-
-    expect(result).toEqual({ tools, abortSignal });
-  });
-
-  it('preserves existing config properties', () => {
-    const config = {
-      model: 'gpt-4',
-      temperature: 0.7,
-      maxTokens: 1000,
-      topP: 0.9,
-    };
-    const result = mergeLLMConfig(config, undefined, undefined);
-
-    expect(result).toEqual(config);
-  });
-
-  it('overwrites tools in config', () => {
-    const config = {
-      model: 'gpt-4',
-      tools: [
-        {
-          type: 'function' as const,
-          function: { name: 'old', description: 'Old', parameters: {} },
-        },
-      ],
-    };
-    const newTools = [
-      { type: 'function' as const, function: { name: 'new', description: 'New', parameters: {} } },
-    ];
-    const result = mergeLLMConfig(config, newTools, undefined);
-
-    expect(result!.tools).toEqual(newTools);
-  });
-
-  it('overwrites abortSignal in config', () => {
-    const oldSignal = new AbortController().signal;
-    const newSignal = new AbortController().signal;
-    const config = {
-      model: 'gpt-4',
-      abortSignal: oldSignal,
-    };
-    const result = mergeLLMConfig(config, undefined, newSignal);
-
-    expect(result!.abortSignal).toBe(newSignal);
-  });
-});

package/vendor/agent-root/src/agent/agent/__test__/telemetry.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import type { AgentCallbacks, AgentMetric, AgentTraceEvent } from '../../types';
-import {
-  emitMetric,
-  emitTrace,
-  endSpan,
-  extractErrorCode,
-  logError,
-  logInfo,
-  logWarn,
-  startSpan,
-} from '../telemetry';
-
-describe('telemetry', () => {
-  it('extractErrorCode reads string errorCode from unknown object', () => {
-    expect(extractErrorCode({ errorCode: 'E1' })).toBe('E1');
-    expect(extractErrorCode({ errorCode: 1 })).toBeUndefined();
-    expect(extractErrorCode(null)).toBeUndefined();
-  });
-
-  it('emitMetric and emitTrace call safeCallback wrappers', async () => {
-    const onMetric = vi.fn(async (_metric: AgentMetric) => undefined);
-    const onTrace = vi.fn(async (_event: AgentTraceEvent) => undefined);
-    const callbacks: AgentCallbacks = {
-      onMessage: async () => undefined,
-      onCheckpoint: async () => undefined,
-      onMetric,
-      onTrace,
-    };
-    const safeCallback: <T>(
-      cb: ((arg: T) => void | Promise<void>) | undefined,
-      arg: T
-    ) => Promise<void> = vi.fn(async (cb, arg) => {
-      await cb?.(arg);
-    });
-
-    await emitMetric(
-      callbacks,
-      { name: 'agent.run.duration_ms', value: 1, unit: 'ms', timestamp: Date.now() },
-      safeCallback
-    );
-    await emitTrace(
-      callbacks,
-      { traceId: 't', spanId: 's', name: 'span', phase: 'start', timestamp: Date.now() },
-      safeCallback
-    );
-
-    expect(onMetric).toHaveBeenCalledOnce();
-    expect(onTrace).toHaveBeenCalledOnce();
-    expect(safeCallback).toHaveBeenCalledTimes(2);
-  });
-
-  it('startSpan and endSpan emit trace start/end events', async () => {
-    const events: unknown[] = [];
-    const callbacks = {} as AgentCallbacks;
-    const emitTraceFn = vi.fn(async (_callbacks: AgentCallbacks | undefined, event: unknown) => {
-      events.push(event);
-    });
-
-    const span = await startSpan({
-      callbacks,
-      traceId: 'trace_1',
-      name: 'agent.run',
-      parentSpanId: 'parent_1',
-      attributes: { a: 1 },
-      createSpanId: () => 'span_1',
-      emitTrace: emitTraceFn,
-    });
-
-    await endSpan({
-      callbacks,
-      span,
-      attributes: { b: 2 },
-      emitTrace: emitTraceFn,
-    });
-
-    expect(events).toHaveLength(2);
-    expect(events[0]).toMatchObject({ phase: 'start', traceId: 'trace_1', spanId: 'span_1' });
-    expect(events[1]).toMatchObject({ phase: 'end', traceId: 'trace_1', spanId: 'span_1' });
-  });
-
-  it('log helpers call corresponding logger methods', () => {
-    const logger = {
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-    };
-
-    logInfo(logger, 'm1', { a: 1 }, { b: 2 });
-    logWarn(logger, 'm2', { c: 3 }, { d: 4 });
-    logError(logger, 'm3', new Error('boom'), { e: 5 });
-
-    expect(logger.info).toHaveBeenCalledOnce();
-    expect(logger.warn).toHaveBeenCalledOnce();
-    expect(logger.error).toHaveBeenCalledOnce();
-  });
-});