@renxqoo/renx-code 0.0.4 → 0.0.5

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

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

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

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

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

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

@@ -0,0 +1,111 @@
+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;
+}