@renxqoo/renx-code 0.0.8 → 0.0.10

package/vendor/agent-root/src/agent/agent/__test__/error-normalizer.test.ts

@@ -1,377 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { isAbortError, normalizeError, calculateRetryDelay } from '../error-normalizer';
-import {
-  LLMAbortedError,
-  LLMAuthError,
-  LLMBadRequestError,
-  LLMError,
-  LLMNotFoundError,
-  LLMPermanentError,
-  LLMRateLimitError,
-  LLMRetryableError,
-} from '../../../providers';
-import {
-  AgentUpstreamAuthError,
-  AgentUpstreamBadRequestError,
-  AgentUpstreamError,
-  AgentUpstreamNetworkError,
-  AgentUpstreamNotFoundError,
-  AgentUpstreamPermanentError,
-  AgentUpstreamRateLimitError,
-  AgentUpstreamRetryableError,
-  AgentUpstreamServerError,
-  AgentUpstreamTimeoutError,
-  AgentAbortedError,
-  AgentError,
-  ConfirmationTimeoutError,
-  UnknownError,
-} from '../error';
-
-describe('isAbortError', () => {
-  it('returns true for AbortError name', () => {
-    const error = { name: 'AbortError', message: 'aborted' };
-    expect(isAbortError(error, 'aborted')).toBe(true);
-  });
-
-  it('returns true for matching aborted message', () => {
-    const error = { name: 'Error', message: 'Operation aborted' };
-    expect(isAbortError(error, 'Operation aborted')).toBe(true);
-  });
-
-  it('returns false for non-abort errors', () => {
-    expect(isAbortError(new Error('other'), 'aborted')).toBe(false);
-    expect(isAbortError(null, 'aborted')).toBe(false);
-    expect(isAbortError(undefined, 'aborted')).toBe(false);
-    expect(isAbortError('string', 'aborted')).toBe(false);
-    expect(isAbortError(123, 'aborted')).toBe(false);
-  });
-
-  it('returns false for object without name or message', () => {
-    expect(isAbortError({}, 'aborted')).toBe(false);
-  });
-});
-
-describe('normalizeError', () => {
-  const abortedMessage = 'Operation aborted';
-
-  it('returns AgentError unchanged', () => {
-    const agentError = new AgentError('test');
-    expect(normalizeError(agentError, abortedMessage)).toBe(agentError);
-  });
-
-  it('converts abort error to AgentAbortedError', () => {
-    const error = { name: 'AbortError', message: 'aborted' };
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentAbortedError);
-    expect(result.message).toBe(abortedMessage);
-  });
-
-  it('converts LLMAbortedError to AgentAbortedError', () => {
-    const error = new LLMAbortedError('llm aborted');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentAbortedError);
-    expect(result.message).toBe('llm aborted');
-  });
-
-  it('converts LLMAbortedError with empty message to default', () => {
-    const error = new LLMAbortedError('');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentAbortedError);
-    expect(result.message).toBe(abortedMessage);
-  });
-
-  it('converts LLMRateLimitError to AgentUpstreamRateLimitError', () => {
-    const error = new LLMRateLimitError('rate limited');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamRateLimitError);
-    expect(result.message).toBe('rate limited');
-  });
-
-  it('converts LLMAuthError to AgentUpstreamAuthError', () => {
-    const error = new LLMAuthError('auth failed');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamAuthError);
-    expect(result.message).toBe('auth failed');
-  });
-
-  it('converts LLMNotFoundError to AgentUpstreamNotFoundError', () => {
-    const error = new LLMNotFoundError('not found');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamNotFoundError);
-    expect(result.message).toBe('not found');
-  });
-
-  it('converts LLMBadRequestError to AgentUpstreamBadRequestError', () => {
-    const error = new LLMBadRequestError('bad request');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamBadRequestError);
-    expect(result.message).toBe('bad request');
-  });
-
-  it('converts LLMRetryableError with RATE_LIMIT code', () => {
-    const error = new LLMRetryableError('rate limit', undefined, 'RATE_LIMIT');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamRateLimitError);
-  });
-
-  it('converts LLMRetryableError with TIMEOUT code', () => {
-    const error = new LLMRetryableError('timeout', undefined, 'TIMEOUT');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamTimeoutError);
-  });
-
-  it('converts LLMRetryableError with BODY_TIMEOUT code', () => {
-    const error = new LLMRetryableError('body timeout', undefined, 'BODY_TIMEOUT');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamTimeoutError);
-  });
-
-  it('converts LLMRetryableError with NETWORK_ERROR code', () => {
-    const error = new LLMRetryableError('network error', undefined, 'NETWORK_ERROR');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamNetworkError);
-  });
-
-  it('converts LLMRetryableError with SERVER_500 code', () => {
-    const error = new LLMRetryableError('server error', undefined, 'SERVER_500');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamServerError);
-  });
-
-  it('converts LLMRetryableError with unknown code to AgentUpstreamRetryableError', () => {
-    const error = new LLMRetryableError('retryable', undefined, 'UNKNOWN');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamRetryableError);
-  });
-
-  it('infers network retryable errors from message when code is missing', () => {
-    const error = new LLMRetryableError(
-      'Network connection lost. (chunk: gen-1773295956-gHGwhy1zWdrqK3KOjVOl)'
-    );
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamNetworkError);
-  });
-
-  it('infers timeout retryable errors from message when code is missing', () => {
-    const error = new LLMRetryableError('Request timed out while streaming response');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamTimeoutError);
-  });
-
-  it('converts LLMPermanentError to AgentUpstreamPermanentError', () => {
-    const error = new LLMPermanentError('permanent');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamPermanentError);
-    expect(result.message).toBe('permanent');
-  });
-
-  it('converts LLMError with ABORTED code', () => {
-    const error = new LLMError('aborted', 'ABORTED');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentAbortedError);
-  });
-
-  it('converts LLMError with AUTH_FAILED code', () => {
-    const error = new LLMError('auth failed', 'AUTH_FAILED');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamAuthError);
-  });
-
-  it('converts LLMError with NOT_FOUND code', () => {
-    const error = new LLMError('not found', 'NOT_FOUND');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamNotFoundError);
-  });
-
-  it('converts LLMError with BAD_REQUEST code', () => {
-    const error = new LLMError('bad request', 'BAD_REQUEST');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamBadRequestError);
-  });
-
-  it('converts LLMError with RATE_LIMIT code', () => {
-    const error = new LLMError('rate limit', 'RATE_LIMIT');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamRateLimitError);
-  });
-
-  it('converts LLMError with TIMEOUT code', () => {
-    const error = new LLMError('timeout', 'TIMEOUT');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamTimeoutError);
-  });
-
-  it('converts LLMError with BODY_TIMEOUT code', () => {
-    const error = new LLMError('body timeout', 'BODY_TIMEOUT');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamTimeoutError);
-  });
-
-  it('converts LLMError with NETWORK_ERROR code', () => {
-    const error = new LLMError('network error', 'NETWORK_ERROR');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamNetworkError);
-  });
-
-  it('converts LLMError with SERVER_500 code', () => {
-    const error = new LLMError('server error', 'SERVER_500');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamServerError);
-  });
-
-  it('converts LLMError with unknown code to AgentUpstreamError', () => {
-    const error = new LLMError('unknown', 'UNKNOWN');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamError);
-  });
-
-  it('converts LLMError with empty message to default', () => {
-    const error = new LLMError('', 'UNKNOWN');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamError);
-  });
-
-  it('converts ConfirmationTimeoutError', () => {
-    const error = new Error('Confirmation timeout');
-    error.name = 'ConfirmationTimeoutError';
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(ConfirmationTimeoutError);
-  });
-
-  it('converts Error with Confirmation timeout message', () => {
-    const error = new Error('Confirmation timeout');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(ConfirmationTimeoutError);
-  });
-
-  it('converts plain network Error to AgentUpstreamNetworkError', () => {
-    const error = new Error('transient network failure');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamNetworkError);
-    expect(result.retryable).toBe(true);
-  });
-
-  it('converts plain timeout Error to AgentUpstreamTimeoutError', () => {
-    const error = new Error('request timed out');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(AgentUpstreamTimeoutError);
-    expect(result.retryable).toBe(true);
-  });
-
-  it('converts generic Error to UnknownError', () => {
-    const error = new Error('generic error');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(UnknownError);
-    expect(result.message).toBe('generic error');
-  });
-
-  it('converts Error with empty message to default UnknownError', () => {
-    const error = new Error('');
-    const result = normalizeError(error, abortedMessage);
-
-    expect(result).toBeInstanceOf(UnknownError);
-  });
-
-  it('converts non-Error to UnknownError', () => {
-    const result = normalizeError('string error', abortedMessage);
-
-    expect(result).toBeInstanceOf(UnknownError);
-  });
-
-  it('converts null to UnknownError', () => {
-    const result = normalizeError(null, abortedMessage);
-
-    expect(result).toBeInstanceOf(UnknownError);
-  });
-
-  it('converts undefined to UnknownError', () => {
-    const result = normalizeError(undefined, abortedMessage);
-
-    expect(result).toBeInstanceOf(UnknownError);
-  });
-});
-
-describe('calculateRetryDelay', () => {
-  const backoffConfig = {
-    initialDelayMs: 1000,
-    maxDelayMs: 10000,
-    base: 2,
-    jitter: false, // Disable jitter for predictable tests
-  };
-
-  it('calculates delay for first retry', () => {
-    const error = new Error('test');
-    const delay = calculateRetryDelay(1, error, backoffConfig);
-
-    expect(delay).toBe(1000);
-  });
-
-  it('calculates delay for second retry', () => {
-    const error = new Error('test');
-    const delay = calculateRetryDelay(2, error, backoffConfig);
-
-    expect(delay).toBe(2000);
-  });
-
-  it('calculates delay for third retry', () => {
-    const error = new Error('test');
-    const delay = calculateRetryDelay(3, error, backoffConfig);
-
-    expect(delay).toBe(4000);
-  });
-
-  it('respects max delay', () => {
-    const error = new Error('test');
-    const delay = calculateRetryDelay(10, error, backoffConfig);
-
-    expect(delay).toBe(10000);
-  });
-
-  it('uses retryAfter from LLMRetryableError', () => {
-    const error = new LLMRetryableError('rate limit', 5000);
-    const delay = calculateRetryDelay(1, error, backoffConfig);
-
-    expect(delay).toBe(5000);
-  });
-
-  it('ignores retryAfter from non-LLMRetryableError', () => {
-    const error = new Error('test');
-    // Add retryAfter property to test that it's ignored for non-LLMRetryableError
-    Object.defineProperty(error, 'retryAfter', { value: 5000 });
-    const delay = calculateRetryDelay(1, error, backoffConfig);
-
-    expect(delay).toBe(1000);
-  });
-});

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

@@ -1,212 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  AgentAbortedError,
-  AgentError,
-  AgentQueryError,
-  AgentUpstreamAuthError,
-  AgentUpstreamBadRequestError,
-  AgentUpstreamError,
-  AgentUpstreamNetworkError,
-  AgentUpstreamNotFoundError,
-  AgentUpstreamPermanentError,
-  AgentUpstreamRateLimitError,
-  AgentUpstreamRetryableError,
-  AgentUpstreamServerError,
-  AgentUpstreamTimeoutError,
-  ConfirmationTimeoutError,
-  MaxRetriesError,
-  TimeoutBudgetExceededError,
-  UnknownError,
-} from '../error';
-
-describe('agent/error', () => {
-  it('builds AgentError with default and custom code', () => {
-    const defaultErr = new AgentError('boom');
-    const customErr = new AgentError('boom2', 2001);
-
-    expect(defaultErr.name).toBe('AgentError');
-    expect(defaultErr.code).toBe(1000);
-    expect(defaultErr.message).toBe('boom');
-    expect(defaultErr.errorCode).toBe('AGENT_ERROR');
-    expect(defaultErr.category).toBe('internal');
-    expect(defaultErr.retryable).toBe(false);
-    expect(defaultErr.httpStatus).toBe(500);
-
-    expect(customErr.code).toBe(2001);
-  });
-
-  it('builds AgentQueryError with defaults', () => {
-    const err = new AgentQueryError();
-
-    expect(err.name).toBe('AgentQueryError');
-    expect(err.code).toBe(1001);
-    expect(err.message).toBe('Query is empty');
-    expect(err.errorCode).toBe('AGENT_QUERY_EMPTY');
-    expect(err.category).toBe('validation');
-    expect(err.retryable).toBe(false);
-    expect(err.httpStatus).toBe(400);
-  });
-
-  it('builds AgentAbortedError', () => {
-    const err = new AgentAbortedError();
-
-    expect(err).toBeInstanceOf(AgentError);
-    expect(err.name).toBe('AgentAbortedError');
-    expect(err.code).toBe(1002);
-    expect(err.message).toBe('Agent was aborted');
-    expect(err.errorCode).toBe('AGENT_ABORTED');
-    expect(err.category).toBe('abort');
-    expect(err.retryable).toBe(false);
-    expect(err.httpStatus).toBe(499);
-  });
-
-  it('builds MaxRetriesError', () => {
-    const err = new MaxRetriesError();
-
-    expect(err).toBeInstanceOf(AgentError);
-    expect(err.name).toBe('MaxRetriesError');
-    expect(err.code).toBe(1003);
-    expect(err.message).toBe('Max retries reached');
-    expect(err.errorCode).toBe('AGENT_MAX_RETRIES_REACHED');
-    expect(err.category).toBe('timeout');
-    expect(err.retryable).toBe(false);
-    expect(err.httpStatus).toBe(504);
-  });
-
-  it('builds ConfirmationTimeoutError', () => {
-    const err = new ConfirmationTimeoutError();
-
-    expect(err).toBeInstanceOf(AgentError);
-    expect(err.name).toBe('ConfirmationTimeoutError');
-    expect(err.code).toBe(1004);
-    expect(err.message).toBe('Confirmation timeout');
-    expect(err.errorCode).toBe('AGENT_CONFIRMATION_TIMEOUT');
-    expect(err.category).toBe('timeout');
-    expect(err.retryable).toBe(true);
-    expect(err.httpStatus).toBe(408);
-  });
-
-  it('builds UnknownError', () => {
-    const err = new UnknownError();
-
-    expect(err).toBeInstanceOf(AgentError);
-    expect(err.name).toBe('UnknownError');
-    expect(err.code).toBe(1005);
-    expect(err.message).toBe('Unknown error');
-    expect(err.errorCode).toBe('AGENT_UNKNOWN_ERROR');
-    expect(err.category).toBe('internal');
-    expect(err.retryable).toBe(false);
-    expect(err.httpStatus).toBe(500);
-  });
-
-  it('builds TimeoutBudgetExceededError', () => {
-    const err = new TimeoutBudgetExceededError();
-
-    expect(err).toBeInstanceOf(AgentError);
-    expect(err.name).toBe('TimeoutBudgetExceededError');
-    expect(err.code).toBe(1006);
-    expect(err.message).toBe('Timeout budget exceeded');
-    expect(err.errorCode).toBe('AGENT_TIMEOUT_BUDGET_EXCEEDED');
-    expect(err.category).toBe('timeout');
-    expect(err.retryable).toBe(false);
-    expect(err.httpStatus).toBe(504);
-  });
-
-  it('builds upstream retryable errors', () => {
-    const rateLimit = new AgentUpstreamRateLimitError('rate limited');
-    const timeout = new AgentUpstreamTimeoutError('timed out');
-    const network = new AgentUpstreamNetworkError('network down');
-    const server = new AgentUpstreamServerError('server 500');
-    const retryable = new AgentUpstreamRetryableError('retry me');
-
-    expect(rateLimit).toMatchObject({
-      name: 'AgentUpstreamRateLimitError',
-      code: 1007,
-      errorCode: 'AGENT_UPSTREAM_RATE_LIMIT',
-      category: 'rate_limit',
-      retryable: true,
-      httpStatus: 429,
-    });
-    expect(timeout).toMatchObject({
-      name: 'AgentUpstreamTimeoutError',
-      code: 1008,
-      errorCode: 'AGENT_UPSTREAM_TIMEOUT',
-      category: 'timeout',
-      retryable: true,
-      httpStatus: 504,
-    });
-    expect(network).toMatchObject({
-      name: 'AgentUpstreamNetworkError',
-      code: 1009,
-      errorCode: 'AGENT_UPSTREAM_NETWORK',
-      category: 'internal',
-      retryable: true,
-      httpStatus: 503,
-    });
-    expect(server).toMatchObject({
-      name: 'AgentUpstreamServerError',
-      code: 1010,
-      errorCode: 'AGENT_UPSTREAM_SERVER',
-      category: 'internal',
-      retryable: true,
-      httpStatus: 502,
-    });
-    expect(retryable).toMatchObject({
-      name: 'AgentUpstreamRetryableError',
-      code: 1015,
-      errorCode: 'AGENT_UPSTREAM_RETRYABLE',
-      category: 'internal',
-      retryable: true,
-      httpStatus: 503,
-    });
-  });
-
-  it('builds upstream non-retryable errors', () => {
-    const auth = new AgentUpstreamAuthError('bad key');
-    const notFound = new AgentUpstreamNotFoundError('missing model');
-    const badRequest = new AgentUpstreamBadRequestError('invalid payload');
-    const permanent = new AgentUpstreamPermanentError('not implemented');
-    const generic = new AgentUpstreamError('provider error');
-
-    expect(auth).toMatchObject({
-      name: 'AgentUpstreamAuthError',
-      code: 1011,
-      errorCode: 'AGENT_UPSTREAM_AUTH',
-      category: 'permission',
-      retryable: false,
-      httpStatus: 401,
-    });
-    expect(notFound).toMatchObject({
-      name: 'AgentUpstreamNotFoundError',
-      code: 1012,
-      errorCode: 'AGENT_UPSTREAM_NOT_FOUND',
-      category: 'not_found',
-      retryable: false,
-      httpStatus: 404,
-    });
-    expect(badRequest).toMatchObject({
-      name: 'AgentUpstreamBadRequestError',
-      code: 1013,
-      errorCode: 'AGENT_UPSTREAM_BAD_REQUEST',
-      category: 'validation',
-      retryable: false,
-      httpStatus: 400,
-    });
-    expect(permanent).toMatchObject({
-      name: 'AgentUpstreamPermanentError',
-      code: 1014,
-      errorCode: 'AGENT_UPSTREAM_PERMANENT',
-      category: 'internal',
-      retryable: false,
-      httpStatus: 500,
-    });
-    expect(generic).toMatchObject({
-      name: 'AgentUpstreamError',
-      code: 1016,
-      errorCode: 'AGENT_UPSTREAM_ERROR',
-      category: 'internal',
-      retryable: false,
-      httpStatus: 500,
-    });
-  });
-});