@renxqoo/renx-code 0.0.4 → 0.0.5

package/vendor/agent-root/src/agent/agent/concurrency.ts

@@ -0,0 +1,103 @@
+import type { ToolCall } from '../../providers';
+import type { ToolConcurrencyPolicy } from '../tool/types';
+
+export interface ToolExecutionPlan {
+  toolCall: ToolCall;
+  policy: ToolConcurrencyPolicy;
+}
+
+export interface ToolExecutionWave {
+  type: 'exclusive' | 'parallel';
+  plans: ToolExecutionPlan[];
+}
+
+export function buildExecutionWaves(plans: ToolExecutionPlan[]): ToolExecutionWave[] {
+  const waves: ToolExecutionWave[] = [];
+  let currentParallel: ToolExecutionPlan[] = [];
+
+  const flushParallel = () => {
+    if (currentParallel.length === 0) {
+      return;
+    }
+    waves.push({ type: 'parallel', plans: currentParallel });
+    currentParallel = [];
+  };
+
+  for (const plan of plans) {
+    if (plan.policy.mode === 'exclusive') {
+      flushParallel();
+      waves.push({ type: 'exclusive', plans: [plan] });
+    } else {
+      currentParallel.push(plan);
+    }
+  }
+  flushParallel();
+
+  return waves;
+}
+
+export async function runWithConcurrencyAndLock<T>(
+  tasks: Array<{ lockKey?: string; run: () => Promise<T> }>,
+  limit: number
+): Promise<T[]> {
+  if (tasks.length === 0) {
+    return [];
+  }
+
+  const results: T[] = new Array(tasks.length);
+  const pending = tasks.map((_, index) => index);
+  const runningLocks = new Set<string>();
+  let activeCount = 0;
+  let settled = false;
+
+  return new Promise<T[]>((resolve, reject) => {
+    const tryStart = () => {
+      while (activeCount < limit && pending.length > 0) {
+        const nextPos = pending.findIndex((index) => {
+          const lockKey = tasks[index].lockKey;
+          return !lockKey || !runningLocks.has(lockKey);
+        });
+        if (nextPos === -1) {
+          break;
+        }
+
+        const taskIndex = pending.splice(nextPos, 1)[0];
+        const lockKey = tasks[taskIndex].lockKey;
+        if (lockKey) {
+          runningLocks.add(lockKey);
+        }
+        activeCount += 1;
+
+        tasks[taskIndex]
+          .run()
+          .then((value) => {
+            results[taskIndex] = value;
+          })
+          .catch((error) => {
+            if (!settled) {
+              settled = true;
+              reject(error);
+            }
+          })
+          .finally(() => {
+            activeCount -= 1;
+            if (lockKey) {
+              runningLocks.delete(lockKey);
+            }
+
+            if (settled) {
+              return;
+            }
+            if (pending.length === 0 && activeCount === 0) {
+              settled = true;
+              resolve(results);
+              return;
+            }
+            tryStart();
+          });
+      }
+    };
+
+    tryStart();
+  });
+}

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

@@ -0,0 +1,190 @@
+import {
+  calculateBackoff,
+  LLMAbortedError,
+  LLMAuthError,
+  LLMBadRequestError,
+  LLMError,
+  LLMNotFoundError,
+  LLMPermanentError,
+  LLMRateLimitError,
+  LLMRetryableError,
+} from '../../providers';
+import type { BackoffConfig } from '../../providers';
+import {
+  AgentUpstreamAuthError,
+  AgentUpstreamBadRequestError,
+  AgentUpstreamError,
+  AgentUpstreamNetworkError,
+  AgentUpstreamNotFoundError,
+  AgentUpstreamPermanentError,
+  AgentUpstreamRateLimitError,
+  AgentUpstreamRetryableError,
+  AgentUpstreamServerError,
+  AgentUpstreamTimeoutError,
+  AgentAbortedError,
+  AgentError,
+  ConfirmationTimeoutError,
+  UnknownError,
+} from './error';
+
+export function isAbortError(error: unknown, abortedMessage: string): boolean {
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+  const abortError = error as { name?: string; message?: string };
+  return abortError.name === 'AbortError' || abortError.message === abortedMessage;
+}
+
+export function normalizeError(error: unknown, abortedMessage: string): AgentError {
+  if (error instanceof AgentError) {
+    return error;
+  }
+
+  if (isAbortError(error, abortedMessage)) {
+    return new AgentAbortedError(abortedMessage);
+  }
+
+  if (error instanceof LLMAbortedError) {
+    return new AgentAbortedError(error.message || abortedMessage);
+  }
+
+  if (error instanceof LLMRateLimitError) {
+    return new AgentUpstreamRateLimitError(error.message);
+  }
+
+  if (error instanceof LLMAuthError) {
+    return new AgentUpstreamAuthError(error.message);
+  }
+
+  if (error instanceof LLMNotFoundError) {
+    return new AgentUpstreamNotFoundError(error.message);
+  }
+
+  if (error instanceof LLMBadRequestError) {
+    return new AgentUpstreamBadRequestError(error.message);
+  }
+
+  if (error instanceof LLMRetryableError) {
+    return mapRetryableProviderError(error);
+  }
+
+  if (error instanceof LLMPermanentError) {
+    return new AgentUpstreamPermanentError(error.message);
+  }
+
+  if (error instanceof LLMError) {
+    return mapGeneralProviderError(error, abortedMessage);
+  }
+
+  if (error instanceof Error) {
+    if (error.name === 'ConfirmationTimeoutError' || error.message === 'Confirmation timeout') {
+      return new ConfirmationTimeoutError(error.message);
+    }
+    const inferredKind = inferRetryableKindFromMessage(error.message);
+    if (inferredKind === 'timeout') {
+      return new AgentUpstreamTimeoutError(error.message);
+    }
+    if (inferredKind === 'network') {
+      return new AgentUpstreamNetworkError(error.message);
+    }
+    return new UnknownError(error.message || new UnknownError().message);
+  }
+
+  return new UnknownError();
+}
+
+export function calculateRetryDelay(
+  retryCount: number,
+  error: Error,
+  backoffConfig: BackoffConfig
+): number {
+  const retryAfterMs = error instanceof LLMRetryableError ? error.retryAfter : undefined;
+  return calculateBackoff(retryCount - 1, retryAfterMs, backoffConfig);
+}
+
+function mapRetryableProviderError(error: LLMRetryableError): AgentError {
+  const providerCode = normalizeProviderCode(error.code);
+  if (providerCode === 'RATE_LIMIT') {
+    return new AgentUpstreamRateLimitError(error.message);
+  }
+  if (providerCode === 'TIMEOUT' || providerCode === 'BODY_TIMEOUT') {
+    return new AgentUpstreamTimeoutError(error.message);
+  }
+  if (providerCode === 'NETWORK_ERROR') {
+    return new AgentUpstreamNetworkError(error.message);
+  }
+  if (isServerCode(providerCode)) {
+    return new AgentUpstreamServerError(error.message);
+  }
+  const inferredKind = inferRetryableKindFromMessage(error.message);
+  if (inferredKind === 'timeout') {
+    return new AgentUpstreamTimeoutError(error.message);
+  }
+  if (inferredKind === 'network') {
+    return new AgentUpstreamNetworkError(error.message);
+  }
+  return new AgentUpstreamRetryableError(error.message);
+}
+
+function mapGeneralProviderError(error: LLMError, abortedMessage: string): AgentError {
+  const providerCode = normalizeProviderCode(error.code);
+  if (providerCode === 'ABORTED') {
+    return new AgentAbortedError(error.message || abortedMessage);
+  }
+  if (providerCode === 'AUTH_FAILED') {
+    return new AgentUpstreamAuthError(error.message);
+  }
+  if (providerCode === 'NOT_FOUND') {
+    return new AgentUpstreamNotFoundError(error.message);
+  }
+  if (providerCode === 'BAD_REQUEST') {
+    return new AgentUpstreamBadRequestError(error.message);
+  }
+  if (providerCode === 'RATE_LIMIT') {
+    return new AgentUpstreamRateLimitError(error.message);
+  }
+  if (providerCode === 'TIMEOUT' || providerCode === 'BODY_TIMEOUT') {
+    return new AgentUpstreamTimeoutError(error.message);
+  }
+  if (providerCode === 'NETWORK_ERROR') {
+    return new AgentUpstreamNetworkError(error.message);
+  }
+  if (isServerCode(providerCode)) {
+    return new AgentUpstreamServerError(error.message);
+  }
+  return new AgentUpstreamError(error.message || new AgentUpstreamError().message);
+}
+
+function normalizeProviderCode(code: string | undefined): string {
+  if (typeof code !== 'string') {
+    return '';
+  }
+  return code.trim().toUpperCase();
+}
+
+function isServerCode(code: string): boolean {
+  return /^SERVER_\d{3}$/.test(code);
+}
+
+function inferRetryableKindFromMessage(
+  message: string | undefined
+): 'network' | 'timeout' | undefined {
+  if (typeof message !== 'string') {
+    return undefined;
+  }
+  const normalized = message.trim().toLowerCase();
+  if (!normalized) {
+    return undefined;
+  }
+  if (/\b(timeout|timed out|body timeout|request timeout|deadline exceeded)\b/.test(normalized)) {
+    return 'timeout';
+  }
+  if (
+    /\b(network|connection|socket|econnreset|econnrefused|enotfound|ehostunreach|etimedout|dns)\b/.test(
+      normalized
+    )
+  ) {
+    return 'network';
+  }
+  return undefined;
+}

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

@@ -0,0 +1,198 @@
+import { ContractError, type ErrorContract } from '../error-contract';
+
+export class AgentError extends ContractError {
+  constructor(message: string, code = 1000) {
+    super(message, {
+      module: 'agent',
+      name: 'AgentError',
+      code,
+      errorCode: 'AGENT_ERROR',
+      category: 'internal',
+      retryable: false,
+      httpStatus: 500,
+    });
+  }
+}
+
+export class AgentQueryError extends ContractError {
+  constructor(message = 'Query is empty', code = 1001) {
+    super(message, {
+      module: 'agent',
+      name: 'AgentQueryError',
+      code,
+      errorCode: 'AGENT_QUERY_EMPTY',
+      category: 'validation',
+      retryable: false,
+      httpStatus: 400,
+    });
+  }
+}
+
+export class AgentAbortedError extends AgentError {
+  constructor(message = 'Agent was aborted', code = 1002) {
+    super(message, code);
+    this.name = 'AgentAbortedError';
+    this.errorCode = 'AGENT_ABORTED';
+    this.category = 'abort';
+    this.retryable = false;
+    this.httpStatus = 499;
+  }
+}
+
+export class MaxRetriesError extends AgentError {
+  constructor(message = 'Max retries reached', code = 1003) {
+    super(message, code);
+    this.name = 'MaxRetriesError';
+    this.errorCode = 'AGENT_MAX_RETRIES_REACHED';
+    this.category = 'timeout';
+    this.retryable = false;
+    this.httpStatus = 504;
+  }
+}
+
+export class ConfirmationTimeoutError extends AgentError {
+  constructor(message = 'Confirmation timeout', code = 1004) {
+    super(message, code);
+    this.name = 'ConfirmationTimeoutError';
+    this.errorCode = 'AGENT_CONFIRMATION_TIMEOUT';
+    this.category = 'timeout';
+    this.retryable = true;
+    this.httpStatus = 408;
+  }
+}
+
+export class UnknownError extends AgentError {
+  constructor(message = 'Unknown error', code = 1005) {
+    super(message, code);
+    this.name = 'UnknownError';
+    this.errorCode = 'AGENT_UNKNOWN_ERROR';
+    this.category = 'internal';
+    this.retryable = false;
+    this.httpStatus = 500;
+  }
+}
+
+export class TimeoutBudgetExceededError extends AgentError {
+  constructor(message = 'Timeout budget exceeded', code = 1006) {
+    super(message, code);
+    this.name = 'TimeoutBudgetExceededError';
+    this.errorCode = 'AGENT_TIMEOUT_BUDGET_EXCEEDED';
+    this.category = 'timeout';
+    this.retryable = false;
+    this.httpStatus = 504;
+  }
+}
+
+export class AgentUpstreamRateLimitError extends AgentError {
+  constructor(message = 'Upstream rate limit exceeded', code = 1007) {
+    super(message, code);
+    this.name = 'AgentUpstreamRateLimitError';
+    this.errorCode = 'AGENT_UPSTREAM_RATE_LIMIT';
+    this.category = 'rate_limit';
+    this.retryable = true;
+    this.httpStatus = 429;
+  }
+}
+
+export class AgentUpstreamTimeoutError extends AgentError {
+  constructor(message = 'Upstream request timed out', code = 1008) {
+    super(message, code);
+    this.name = 'AgentUpstreamTimeoutError';
+    this.errorCode = 'AGENT_UPSTREAM_TIMEOUT';
+    this.category = 'timeout';
+    this.retryable = true;
+    this.httpStatus = 504;
+  }
+}
+
+export class AgentUpstreamNetworkError extends AgentError {
+  constructor(message = 'Upstream network request failed', code = 1009) {
+    super(message, code);
+    this.name = 'AgentUpstreamNetworkError';
+    this.errorCode = 'AGENT_UPSTREAM_NETWORK';
+    this.category = 'internal';
+    this.retryable = true;
+    this.httpStatus = 503;
+  }
+}
+
+export class AgentUpstreamServerError extends AgentError {
+  constructor(message = 'Upstream server error', code = 1010) {
+    super(message, code);
+    this.name = 'AgentUpstreamServerError';
+    this.errorCode = 'AGENT_UPSTREAM_SERVER';
+    this.category = 'internal';
+    this.retryable = true;
+    this.httpStatus = 502;
+  }
+}
+
+export class AgentUpstreamAuthError extends AgentError {
+  constructor(message = 'Upstream authentication failed', code = 1011) {
+    super(message, code);
+    this.name = 'AgentUpstreamAuthError';
+    this.errorCode = 'AGENT_UPSTREAM_AUTH';
+    this.category = 'permission';
+    this.retryable = false;
+    this.httpStatus = 401;
+  }
+}
+
+export class AgentUpstreamNotFoundError extends AgentError {
+  constructor(message = 'Upstream resource not found', code = 1012) {
+    super(message, code);
+    this.name = 'AgentUpstreamNotFoundError';
+    this.errorCode = 'AGENT_UPSTREAM_NOT_FOUND';
+    this.category = 'not_found';
+    this.retryable = false;
+    this.httpStatus = 404;
+  }
+}
+
+export class AgentUpstreamBadRequestError extends AgentError {
+  constructor(message = 'Upstream request is invalid', code = 1013) {
+    super(message, code);
+    this.name = 'AgentUpstreamBadRequestError';
+    this.errorCode = 'AGENT_UPSTREAM_BAD_REQUEST';
+    this.category = 'validation';
+    this.retryable = false;
+    this.httpStatus = 400;
+  }
+}
+
+export class AgentUpstreamPermanentError extends AgentError {
+  constructor(message = 'Upstream permanent error', code = 1014) {
+    super(message, code);
+    this.name = 'AgentUpstreamPermanentError';
+    this.errorCode = 'AGENT_UPSTREAM_PERMANENT';
+    this.category = 'internal';
+    this.retryable = false;
+    this.httpStatus = 500;
+  }
+}
+
+export class AgentUpstreamRetryableError extends AgentError {
+  constructor(message = 'Upstream retryable error', code = 1015) {
+    super(message, code);
+    this.name = 'AgentUpstreamRetryableError';
+    this.errorCode = 'AGENT_UPSTREAM_RETRYABLE';
+    this.category = 'internal';
+    this.retryable = true;
+    this.httpStatus = 503;
+  }
+}
+
+export class AgentUpstreamError extends AgentError {
+  constructor(message = 'Upstream error', code = 1016) {
+    super(message, code);
+    this.name = 'AgentUpstreamError';
+    this.errorCode = 'AGENT_UPSTREAM_ERROR';
+    this.category = 'internal';
+    this.retryable = false;
+    this.httpStatus = 500;
+  }
+}
+
+export function toAgentErrorContract(error: AgentError): ErrorContract {
+  return error.toJSON();
+}