@renxqoo/renx-code 0.0.9 → 0.0.10

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

@@ -1,65 +0,0 @@
-export interface AgentLogContext {
-  executionId?: string;
-  traceId?: string;
-  spanId?: string;
-  parentSpanId?: string;
-  stepIndex?: number;
-  toolCallId?: string;
-  toolName?: string;
-  errorCode?: string;
-  category?: string;
-  retryCount?: number;
-  messageCount?: number;
-  latencyMs?: number;
-  [key: string]: unknown;
-}
-
-export interface AgentLogger {
-  error?: (message: string, error?: unknown, context?: AgentLogContext) => void;
-  warn?: (message: string, context?: AgentLogContext, data?: unknown) => void;
-  info?: (message: string, context?: AgentLogContext, data?: unknown) => void;
-  debug?: (message: string, context?: AgentLogContext, data?: unknown) => void;
-}
-
-export interface CoreStructuredLoggerLike {
-  error: (message: string, error?: unknown, context?: Record<string, unknown>) => void;
-  warn: (message: string, context?: Record<string, unknown>, data?: unknown) => void;
-  info: (message: string, context?: Record<string, unknown>, data?: unknown) => void;
-  debug: (message: string, context?: Record<string, unknown>, data?: unknown) => void;
-}
-
-export function createAgentLoggerAdapter(
-  logger: CoreStructuredLoggerLike,
-  baseContext: AgentLogContext = {}
-): AgentLogger {
-  const withContext = (context?: AgentLogContext): AgentLogContext => ({
-    ...baseContext,
-    ...(context || {}),
-  });
-
-  return {
-    debug: (message, context, data) => logger.debug(message, withContext(context), data),
-    info: (message, context, data) => logger.info(message, withContext(context), data),
-    warn: (message, context, data) => logger.warn(message, withContext(context), data),
-    error: (message, error, context) => logger.error(message, error, withContext(context)),
-  };
-}
-
-export function mergeAgentLoggers(primary: AgentLogger, secondary: AgentLogger): AgentLogger {
-  const callBoth = <T extends unknown[]>(
-    first: ((...args: T) => void) | undefined,
-    second: ((...args: T) => void) | undefined
-  ) => {
-    return (...args: T) => {
-      first?.(...args);
-      second?.(...args);
-    };
-  };
-
-  return {
-    debug: callBoth(primary.debug, secondary.debug),
-    info: callBoth(primary.info, secondary.info),
-    warn: callBoth(primary.warn, secondary.warn),
-    error: callBoth(primary.error, secondary.error),
-  };
-}

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

@@ -1,101 +0,0 @@
-import type { LLMRequestMessage, MessageContent, ToolCall } from '../../providers';
-import type { AgentInput, Message } from '../types';
-
-function hasNonEmptyTextContent(content: MessageContent | undefined): boolean {
-  if (typeof content === 'string') {
-    return content.trim().length > 0;
-  }
-  if (!Array.isArray(content)) {
-    return false;
-  }
-  return content.some((part) => {
-    if (part.type === 'text') {
-      return typeof part.text === 'string' && part.text.trim().length > 0;
-    }
-    return true;
-  });
-}
-
-function hasNonEmptyReasoningContent(reasoningContent: string | undefined): boolean {
-  return typeof reasoningContent === 'string' && reasoningContent.trim().length > 0;
-}
-
-export function shouldSendMessageToLLM(message: Message): boolean {
-  if (message.role !== 'assistant' || message.type !== 'assistant-text') {
-    return true;
-  }
-
-  const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
-  if (hasToolCalls) {
-    return true;
-  }
-
-  return (
-    hasNonEmptyTextContent(message.content) ||
-    hasNonEmptyReasoningContent(message.reasoning_content)
-  );
-}
-
-export function convertMessageToLLMMessage(message: Message): LLMRequestMessage {
-  return {
-    role: message.role,
-    content: message.content,
-    tool_call_id: message.tool_call_id,
-    tool_calls: sanitizeToolCallsForRequest(message.tool_calls),
-    id: message.id,
-    reasoning_content: message.reasoning_content,
-  };
-}
-
-function sanitizeToolCallsForRequest(
-  toolCalls: Message['tool_calls']
-): LLMRequestMessage['tool_calls'] {
-  if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
-    return toolCalls;
-  }
-
-  return toolCalls.map((toolCall) => ({
-    ...toolCall,
-    function: {
-      ...toolCall.function,
-      arguments: sanitizeToolCallArguments(toolCall.function?.arguments),
-    },
-  })) as ToolCall[];
-}
-
-function sanitizeToolCallArguments(argumentsText: unknown): string {
-  if (typeof argumentsText !== 'string' || argumentsText.trim().length === 0) {
-    return '{}';
-  }
-
-  try {
-    JSON.parse(argumentsText);
-    return argumentsText;
-  } catch {
-    return '{}';
-  }
-}
-
-export function mergeLLMConfig(
-  config: AgentInput['config'],
-  tools?: AgentInput['tools'],
-  abortSignal?: AbortSignal
-): AgentInput['config'] {
-  if (!config && !tools && !abortSignal) {
-    return undefined;
-  }
-
-  const merged: NonNullable<AgentInput['config']> = {
-    ...(config || {}),
-  };
-
-  if (tools && tools.length > 0) {
-    merged.tools = tools;
-  }
-
-  if (abortSignal) {
-    merged.abortSignal = abortSignal;
-  }
-
-  return merged;
-}

package/vendor/agent-root/src/agent/agent/stream-events.ts

@@ -1,61 +0,0 @@
-import type { AgentError } from './error';
-import type { ExecutionCheckpoint, StreamEvent } from '../types';
-
-export function createCheckpoint(
-  executionId: string | undefined,
-  stepIndex: number,
-  lastMessageId: string | undefined
-): ExecutionCheckpoint {
-  return {
-    executionId: executionId || '',
-    stepIndex,
-    lastMessageId: lastMessageId || '',
-    lastMessageTime: Date.now(),
-    canResume: true,
-  };
-}
-
-export function createProgressEvent(
-  executionId: string | undefined,
-  stepIndex: number,
-  currentAction: 'llm' | 'tool',
-  messageCount: number
-): StreamEvent {
-  return {
-    type: 'progress',
-    data: {
-      executionId,
-      stepIndex,
-      currentAction,
-      messageCount,
-    },
-  };
-}
-
-export function createErrorEvent(error: AgentError): StreamEvent {
-  return {
-    type: 'error',
-    data: {
-      name: error.name,
-      code: error.code,
-      errorCode: error.errorCode,
-      category: error.category,
-      retryable: error.retryable,
-      httpStatus: error.httpStatus,
-      message: error.message,
-    },
-  };
-}
-
-export function createDoneEvent(
-  stepIndex: number,
-  finishReason: 'stop' | 'max_steps' = 'stop'
-): StreamEvent {
-  return {
-    type: 'done',
-    data: {
-      finishReason,
-      steps: stepIndex,
-    },
-  };
-}

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

@@ -1,123 +0,0 @@
-import type { AgentCallbacks, AgentMetric, AgentTraceEvent } from '../types';
-import type { AgentLogger } from './logger';
-
-export interface SpanRuntime {
-  traceId: string;
-  spanId: string;
-  parentSpanId?: string;
-  name: string;
-  startedAt: number;
-}
-
-export async function emitMetric(
-  callbacks: AgentCallbacks | undefined,
-  metric: AgentMetric,
-  safeCallback: <T>(
-    callback: ((arg: T) => void | Promise<void>) | undefined,
-    arg: T
-  ) => Promise<void>
-): Promise<void> {
-  await safeCallback(callbacks?.onMetric, metric);
-}
-
-export async function emitTrace(
-  callbacks: AgentCallbacks | undefined,
-  event: AgentTraceEvent,
-  safeCallback: <T>(
-    callback: ((arg: T) => void | Promise<void>) | undefined,
-    arg: T
-  ) => Promise<void>
-): Promise<void> {
-  await safeCallback(callbacks?.onTrace, event);
-}
-
-export async function startSpan(params: {
-  callbacks: AgentCallbacks | undefined;
-  traceId: string;
-  name: string;
-  parentSpanId?: string;
-  attributes?: Record<string, unknown>;
-  createSpanId: () => string;
-  emitTrace: (callbacks: AgentCallbacks | undefined, event: AgentTraceEvent) => Promise<void>;
-}): Promise<SpanRuntime> {
-  const {
-    callbacks,
-    traceId,
-    name,
-    parentSpanId,
-    attributes,
-    createSpanId,
-    emitTrace: emitTraceFn,
-  } = params;
-  const startedAt = Date.now();
-  const span: SpanRuntime = {
-    traceId,
-    spanId: createSpanId(),
-    parentSpanId,
-    name,
-    startedAt,
-  };
-  await emitTraceFn(callbacks, {
-    traceId: span.traceId,
-    spanId: span.spanId,
-    parentSpanId: span.parentSpanId,
-    name: span.name,
-    phase: 'start',
-    timestamp: startedAt,
-    attributes,
-  });
-  return span;
-}
-
-export async function endSpan(params: {
-  callbacks: AgentCallbacks | undefined;
-  span: SpanRuntime;
-  attributes?: Record<string, unknown>;
-  emitTrace: (callbacks: AgentCallbacks | undefined, event: AgentTraceEvent) => Promise<void>;
-}): Promise<void> {
-  const { callbacks, span, attributes, emitTrace: emitTraceFn } = params;
-  await emitTraceFn(callbacks, {
-    traceId: span.traceId,
-    spanId: span.spanId,
-    parentSpanId: span.parentSpanId,
-    name: span.name,
-    phase: 'end',
-    timestamp: Date.now(),
-    attributes,
-  });
-}
-
-export function extractErrorCode(error: unknown): string | undefined {
-  if (!error || typeof error !== 'object') {
-    return undefined;
-  }
-  const maybeCode = (error as { errorCode?: unknown }).errorCode;
-  return typeof maybeCode === 'string' ? maybeCode : undefined;
-}
-
-export function logError(
-  logger: AgentLogger,
-  message: string,
-  error: unknown,
-  context?: Record<string, unknown>
-): void {
-  logger.error?.(message, error, context);
-}
-
-export function logInfo(
-  logger: AgentLogger,
-  message: string,
-  context?: Record<string, unknown>,
-  data?: unknown
-): void {
-  logger.info?.(message, context, data);
-}
-
-export function logWarn(
-  logger: AgentLogger,
-  message: string,
-  context?: Record<string, unknown>,
-  data?: unknown
-): void {
-  logger.warn?.(message, context, data);
-}

package/vendor/agent-root/src/agent/agent/timeout-budget.ts

@@ -1,227 +0,0 @@
-export type TimeoutStage = 'llm' | 'tool';
-
-export interface TimeoutBudgetState {
-  totalMs: number;
-  startedAt: number;
-  llmRemainingMs: number;
-  toolRemainingMs: number;
-}
-
-export interface TimeoutBudgetReason {
-  type: 'agent-timeout-budget';
-  stage: 'total' | TimeoutStage;
-  message: string;
-}
-
-export interface AbortScope {
-  signal?: AbortSignal;
-  release: () => void;
-}
-
-export function getAbortReason(signal: AbortSignal): unknown {
-  return (signal as AbortSignal & { reason?: unknown }).reason;
-}
-
-export function combineAbortSignals(primary?: AbortSignal, secondary?: AbortSignal): AbortScope {
-  if (!primary && !secondary) {
-    return { signal: undefined, release: () => undefined };
-  }
-  if (!primary || primary === secondary) {
-    return { signal: secondary || primary, release: () => undefined };
-  }
-  if (!secondary) {
-    return { signal: primary, release: () => undefined };
-  }
-
-  const controller = new AbortController();
-  const abortFromPrimary = () => {
-    if (!controller.signal.aborted) {
-      controller.abort(getAbortReason(primary));
-    }
-  };
-  const abortFromSecondary = () => {
-    if (!controller.signal.aborted) {
-      controller.abort(getAbortReason(secondary));
-    }
-  };
-
-  if (primary.aborted) {
-    abortFromPrimary();
-  } else {
-    primary.addEventListener('abort', abortFromPrimary, { once: true });
-  }
-
-  if (secondary.aborted) {
-    abortFromSecondary();
-  } else {
-    secondary.addEventListener('abort', abortFromSecondary, { once: true });
-  }
-
-  return {
-    signal: controller.signal,
-    release: () => {
-      primary.removeEventListener('abort', abortFromPrimary);
-      secondary.removeEventListener('abort', abortFromSecondary);
-    },
-  };
-}
-
-export function getTotalRemainingBudgetMs(timeoutBudget: TimeoutBudgetState): number {
-  const elapsed = Date.now() - timeoutBudget.startedAt;
-  return Math.max(0, timeoutBudget.totalMs - elapsed);
-}
-
-export function consumeStageBudget(
-  timeoutBudget: TimeoutBudgetState,
-  stage: TimeoutStage,
-  elapsedMs: number
-): void {
-  const consumed = Math.max(0, Math.floor(elapsedMs));
-  if (stage === 'llm') {
-    timeoutBudget.llmRemainingMs = Math.max(0, timeoutBudget.llmRemainingMs - consumed);
-    return;
-  }
-  timeoutBudget.toolRemainingMs = Math.max(0, timeoutBudget.toolRemainingMs - consumed);
-}
-
-export function createTimeoutBudgetReason(
-  stage: 'total' | TimeoutStage,
-  budgetMs: number
-): TimeoutBudgetReason {
-  const stageLabel = stage === 'total' ? 'execution' : stage;
-  return {
-    type: 'agent-timeout-budget',
-    stage,
-    message: `Timeout budget exceeded at ${stageLabel} stage (budgetMs=${budgetMs})`,
-  };
-}
-
-export function isTimeoutBudgetReason(value: unknown): value is TimeoutBudgetReason {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-  const reason = value as { type?: string; stage?: string; message?: string };
-  return (
-    reason.type === 'agent-timeout-budget' &&
-    typeof reason.stage === 'string' &&
-    typeof reason.message === 'string'
-  );
-}
-
-export function timeoutBudgetReasonFromSignal(
-  signal: AbortSignal | undefined
-): TimeoutBudgetReason | undefined {
-  if (!signal?.aborted) {
-    return undefined;
-  }
-  const reason = getAbortReason(signal);
-  if (!isTimeoutBudgetReason(reason)) {
-    return undefined;
-  }
-  return reason;
-}
-
-export function createTimeoutBudgetState(options: {
-  inputTimeoutBudgetMs?: number;
-  configTimeoutBudgetMs?: number;
-  inputLlmTimeoutRatio?: number;
-  configLlmTimeoutRatio: number;
-}): TimeoutBudgetState | undefined {
-  const configuredTotal =
-    options.inputTimeoutBudgetMs &&
-    Number.isFinite(options.inputTimeoutBudgetMs) &&
-    options.inputTimeoutBudgetMs > 0
-      ? Math.floor(options.inputTimeoutBudgetMs)
-      : options.configTimeoutBudgetMs;
-
-  if (!configuredTotal || configuredTotal <= 0) {
-    return undefined;
-  }
-
-  const ratioValue = Number.isFinite(options.inputLlmTimeoutRatio)
-    ? Number(options.inputLlmTimeoutRatio)
-    : options.configLlmTimeoutRatio;
-  const ratio = Math.min(0.95, Math.max(0.05, ratioValue));
-  const llmRemainingMs = Math.max(1, Math.floor(configuredTotal * ratio));
-  const toolRemainingMs = Math.max(0, configuredTotal - llmRemainingMs);
-
-  return {
-    totalMs: configuredTotal,
-    startedAt: Date.now(),
-    llmRemainingMs,
-    toolRemainingMs,
-  };
-}
-
-export function createExecutionAbortScope(
-  inputAbortSignal: AbortSignal | undefined,
-  timeoutBudget: TimeoutBudgetState | undefined
-): AbortScope {
-  if (!timeoutBudget) {
-    return {
-      signal: inputAbortSignal,
-      release: () => undefined,
-    };
-  }
-
-  const timeoutController = new AbortController();
-  const timer = setTimeout(() => {
-    timeoutController.abort(createTimeoutBudgetReason('total', timeoutBudget.totalMs));
-  }, timeoutBudget.totalMs);
-
-  const combinedScope = combineAbortSignals(inputAbortSignal, timeoutController.signal);
-  return {
-    signal: combinedScope.signal,
-    release: () => {
-      clearTimeout(timer);
-      combinedScope.release();
-    },
-  };
-}
-
-export function createStageAbortScope(
-  baseSignal: AbortSignal | undefined,
-  timeoutBudget: TimeoutBudgetState | undefined,
-  stage: TimeoutStage
-): AbortScope {
-  if (!timeoutBudget) {
-    return {
-      signal: baseSignal,
-      release: () => undefined,
-    };
-  }
-
-  const remainingStageMs =
-    stage === 'llm' ? timeoutBudget.llmRemainingMs : timeoutBudget.toolRemainingMs;
-  const remainingTotalMs = getTotalRemainingBudgetMs(timeoutBudget);
-  const allowedStageMs = Math.min(remainingStageMs, remainingTotalMs);
-  const startedAt = Date.now();
-
-  if (allowedStageMs <= 0) {
-    const exhaustedController = new AbortController();
-    exhaustedController.abort(createTimeoutBudgetReason(stage, 0));
-    const exhaustedScope = combineAbortSignals(baseSignal, exhaustedController.signal);
-    return {
-      signal: exhaustedScope.signal,
-      release: () => {
-        exhaustedScope.release();
-        consumeStageBudget(timeoutBudget, stage, Date.now() - startedAt);
-      },
-    };
-  }
-
-  const stageController = new AbortController();
-  const timer = setTimeout(() => {
-    stageController.abort(createTimeoutBudgetReason(stage, allowedStageMs));
-  }, allowedStageMs);
-  const mergedScope = combineAbortSignals(baseSignal, stageController.signal);
-
-  return {
-    signal: mergedScope.signal,
-    release: () => {
-      clearTimeout(timer);
-      mergedScope.release();
-      consumeStageBudget(timeoutBudget, stage, Date.now() - startedAt);
-    },
-  };
-}

package/vendor/agent-root/src/agent/agent/tool-call-merge.ts

@@ -1,111 +0,0 @@
-import type { ToolCall } from '../../providers';
-
-export async function mergeToolCalls(params: {
-  existing: ToolCall[];
-  incoming: ToolCall[];
-  messageId: string;
-  onArgumentsChunk: (
-    toolCall: ToolCall,
-    argumentsChunk: string,
-    messageId: string
-  ) => Promise<void>;
-}): Promise<ToolCall[]> {
-  const { existing, incoming, messageId, onArgumentsChunk } = params;
-  const result = existing.map((call) => ({
-    ...call,
-    function: {
-      ...(call.function || {}),
-      arguments: call.function?.arguments || '',
-    },
-  }));
-  const byId = new Map<string, ToolCall>();
-  const byIndex = new Map<number, ToolCall>();
-
-  for (const call of result) {
-    registerCallMaps(call, byId, byIndex);
-  }
-
-  for (const newCall of incoming) {
-    const existingCall = findExistingCall(newCall, byId, byIndex);
-    const argumentsChunk = newCall.function?.arguments || '';
-
-    if (existingCall) {
-      if (isPresent(newCall.id) && newCall.id !== existingCall.id) {
-        if (isPresent(existingCall.id)) {
-          byId.delete(existingCall.id);
-        }
-        existingCall.id = newCall.id;
-        byId.set(newCall.id, existingCall);
-      }
-      if (isPresent(newCall.function?.name)) {
-        existingCall.function.name = newCall.function.name;
-      }
-      if (isPresent(newCall.type)) {
-        existingCall.type = newCall.type;
-      }
-      if (typeof newCall.index === 'number' && newCall.index !== existingCall.index) {
-        if (typeof existingCall.index === 'number') {
-          byIndex.delete(existingCall.index);
-        }
-        existingCall.index = newCall.index;
-        byIndex.set(existingCall.index, existingCall);
-      }
-      existingCall.function.arguments += argumentsChunk;
-      if (argumentsChunk) {
-        await onArgumentsChunk(existingCall, argumentsChunk, messageId);
-      }
-    } else {
-      const normalized = createToolCallFromLLM(newCall);
-      result.push(normalized);
-      registerCallMaps(normalized, byId, byIndex);
-      if (argumentsChunk) {
-        await onArgumentsChunk(normalized, argumentsChunk, messageId);
-      }
-    }
-  }
-  return result;
-}
-
-function registerCallMaps(
-  call: ToolCall,
-  byId: Map<string, ToolCall>,
-  byIndex: Map<number, ToolCall>
-): void {
-  if (isPresent(call.id)) {
-    byId.set(call.id, call);
-  }
-  if (typeof call.index === 'number') {
-    byIndex.set(call.index, call);
-  }
-}
-
-function findExistingCall(
-  incoming: ToolCall,
-  byId: Map<string, ToolCall>,
-  byIndex: Map<number, ToolCall>
-): ToolCall | undefined {
-  if (isPresent(incoming.id)) {
-    const matchedById = byId.get(incoming.id);
-    if (matchedById) {
-      return matchedById;
-    }
-  }
-  if (typeof incoming.index === 'number') {
-    return byIndex.get(incoming.index);
-  }
-  return undefined;
-}
-
-function createToolCallFromLLM(incoming: ToolCall): ToolCall {
-  return {
-    ...incoming,
-    function: {
-      ...(incoming.function || {}),
-      arguments: incoming.function?.arguments || '',
-    },
-  };
-}
-
-function isPresent(value: string | undefined): value is string {
-  return typeof value === 'string' && value.length > 0;
-}