@renxqoo/renx-code 0.0.4 → 0.0.6

package/vendor/agent-root/src/agent/app/agent-app-service.ts

@@ -0,0 +1,748 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { LLMGenerateOptions, MessageContent, Tool, Usage } from '../../providers';
+import { StatelessAgent } from '../agent';
+import type { AgentLogContext, AgentLogger } from '../agent/logger';
+import type { AgentCallbacks, Message } from '../types';
+import type {
+  CliEventEnvelope,
+  CompactionDroppedMessageRecord,
+  ListRunsOptions,
+  ListRunsResult,
+  RunRecord,
+  RunLogLevel,
+  RunLogRecord,
+  TerminalReason,
+} from './contracts';
+import type {
+  ContextProjectionStorePort,
+  EventStorePort,
+  ExecutionStorePort,
+  MessageProjectionStorePort,
+  RunLogStorePort,
+} from './ports';
+
+type RunFinishReason = 'stop' | 'max_steps' | 'error';
+
+interface ErrorEventPayload {
+  errorCode?: string;
+  category?: string;
+  message?: string;
+  code?: string;
+  retryable?: boolean;
+  httpStatus?: number;
+  name?: string;
+}
+
+export interface RunForegroundRequest {
+  conversationId: string;
+  userInput: MessageContent;
+  executionId?: string;
+  historyMessages?: Message[];
+  systemPrompt?: string;
+  tools?: Tool[];
+  config?: LLMGenerateOptions;
+  maxSteps?: number;
+  abortSignal?: AbortSignal;
+  timeoutBudgetMs?: number;
+  llmTimeoutRatio?: number;
+  contextLimitTokens?: number;
+  modelLabel?: string;
+}
+
+export interface RunForegroundUsage {
+  sequence: number;
+  stepIndex: number;
+  messageId: string;
+  usage: Usage;
+  cumulativeUsage: Usage;
+  contextTokens?: number;
+  contextLimitTokens?: number;
+  contextUsagePercent?: number;
+}
+
+export interface RunForegroundCallbacks extends Partial<AgentCallbacks> {
+  onToolStream?: (event: CliEventEnvelope) => void | Promise<void>;
+  onEvent?: (event: CliEventEnvelope) => void | Promise<void>;
+  onUsage?: (usage: RunForegroundUsage) => void | Promise<void>;
+}
+
+export interface RunForegroundResult {
+  executionId: string;
+  conversationId: string;
+  messages: Message[];
+  events: CliEventEnvelope[];
+  finishReason: RunFinishReason;
+  steps: number;
+  run: RunRecord;
+}
+
+export interface AgentAppServiceDeps {
+  agent: StatelessAgent;
+  executionStore: ExecutionStorePort;
+  eventStore: EventStorePort;
+  messageStore?: MessageProjectionStorePort;
+  runLogStore?: RunLogStorePort;
+}
+
+interface RunObservabilityContext {
+  executionId: string;
+  conversationId: string;
+  getStepIndex: () => number;
+  enqueue: (task: () => Promise<void>) => void;
+  appendEvent: (eventType: CliEventEnvelope['eventType'], data: unknown) => Promise<void>;
+}
+
+export class AgentAppService {
+  private readonly observabilityScope = new AsyncLocalStorage<RunObservabilityContext>();
+
+  constructor(private readonly deps: AgentAppServiceDeps) {
+    this.deps.agent.attachLogger(this.createScopedLogger());
+  }
+
+  async runForeground(
+    request: RunForegroundRequest,
+    callbacks?: RunForegroundCallbacks
+  ): Promise<RunForegroundResult> {
+    const executionId = request.executionId ?? createId('exec_');
+    const now = Date.now();
+    const baseMessages = request.historyMessages ? [...request.historyMessages] : [];
+    const userMessage = createUserMessage(request.userInput);
+    const inputMessages = [...baseMessages, userMessage];
+    const emittedMessages: Message[] = [];
+    const events: CliEventEnvelope[] = [];
+    let finishReason: RunFinishReason = 'error';
+    let currentStepIndex = 0;
+    let steps = 0;
+    let terminalEventSeen = false;
+    let latestErrorPayload: ErrorEventPayload | undefined;
+    let streamFailure: unknown;
+    let toolStreamFailure: unknown;
+    const cumulativeUsage: Usage = {
+      prompt_tokens: 0,
+      completion_tokens: 0,
+      total_tokens: 0,
+    };
+    let usageSequence = 0;
+    let latestContextUsage:
+      | {
+          stepIndex: number;
+          contextTokens: number;
+          contextLimitTokens: number;
+          contextUsagePercent: number;
+        }
+      | undefined;
+
+    await this.deps.executionStore.create({
+      executionId,
+      runId: executionId,
+      conversationId: request.conversationId,
+      status: 'CREATED',
+      createdAt: now,
+      updatedAt: now,
+      stepIndex: 0,
+    });
+
+    const appendAndProject = async (
+      eventType: CliEventEnvelope['eventType'],
+      data: unknown
+    ): Promise<CliEventEnvelope> => {
+      const envelope = await this.deps.eventStore.appendAutoSeq({
+        executionId,
+        conversationId: request.conversationId,
+        eventType,
+        data,
+        createdAt: Date.now(),
+      });
+      events.push(envelope);
+      if (this.deps.messageStore) {
+        await this.deps.messageStore.upsertFromEvent(envelope);
+      }
+      if (eventType === 'tool_stream') {
+        await callbacks?.onToolStream?.(envelope);
+      }
+      await callbacks?.onEvent?.(envelope);
+      return envelope;
+    };
+
+    await appendAndProject('user_message', { message: userMessage, stepIndex: 0 });
+    await this.deps.executionStore.patch(executionId, {
+      status: 'RUNNING',
+      startedAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    let toolEventQueue: Promise<void> = Promise.resolve();
+    let observabilityQueue: Promise<void> = Promise.resolve();
+    const toolChunkListener = (payload: unknown): void => {
+      toolEventQueue = toolEventQueue
+        .then(async () => {
+          await appendAndProject('tool_stream', payload);
+        })
+        .catch((error: unknown) => {
+          toolStreamFailure = error;
+        });
+    };
+
+    const enqueueObservabilityTask = (task: () => Promise<void>) => {
+      observabilityQueue = observabilityQueue.then(task).catch((error: unknown) => {
+        if (!streamFailure) {
+          streamFailure = error;
+        }
+      });
+    };
+
+    this.deps.agent.on('tool_chunk', toolChunkListener);
+
+    const agentCallbacks: AgentCallbacks = {
+      onContextUsage: async (contextUsage) => {
+        latestContextUsage = {
+          stepIndex: contextUsage.stepIndex,
+          contextTokens: contextUsage.contextTokens,
+          contextLimitTokens: contextUsage.contextLimitTokens,
+          contextUsagePercent: contextUsage.contextUsagePercent,
+        };
+        await callbacks?.onContextUsage?.(contextUsage);
+      },
+      onMessage: async (message) => {
+        // 添加模型信息到消息的 metadata 中
+        if (request.modelLabel && message.role === 'assistant') {
+          message.metadata = {
+            ...message.metadata,
+            modelLabel: request.modelLabel,
+          };
+        }
+        emittedMessages.push(message);
+        await appendAndProject('assistant_message', {
+          message,
+          stepIndex: currentStepIndex,
+        });
+        const usage = readUsage(message.usage);
+        if (message.role === 'assistant' && usage) {
+          usageSequence += 1;
+          cumulativeUsage.prompt_tokens += usage.prompt_tokens;
+          cumulativeUsage.completion_tokens += usage.completion_tokens;
+          cumulativeUsage.total_tokens += usage.total_tokens;
+          const usageStepIndex = latestContextUsage?.stepIndex ?? currentStepIndex;
+
+          const usagePayload: RunForegroundUsage = {
+            sequence: usageSequence,
+            stepIndex: usageStepIndex,
+            messageId: message.messageId,
+            usage,
+            cumulativeUsage: { ...cumulativeUsage },
+            contextTokens: latestContextUsage?.contextTokens,
+            contextLimitTokens: latestContextUsage?.contextLimitTokens,
+            contextUsagePercent: latestContextUsage?.contextUsagePercent,
+          };
+          await callbacks?.onUsage?.(usagePayload);
+        }
+        await callbacks?.onMessage?.(message);
+      },
+      onCheckpoint: async (checkpoint) => {
+        await callbacks?.onCheckpoint?.(checkpoint);
+      },
+      onProgress: callbacks?.onProgress,
+      onCompaction: callbacks?.onCompaction,
+      onMetric: async (metric) => {
+        enqueueObservabilityTask(async () => {
+          await appendAndProject('metric', metric);
+        });
+        await callbacks?.onMetric?.(metric);
+      },
+      onTrace: async (event) => {
+        enqueueObservabilityTask(async () => {
+          await appendAndProject('trace', event);
+        });
+        await callbacks?.onTrace?.(event);
+      },
+      onToolPolicy: callbacks?.onToolPolicy,
+      onError: callbacks?.onError,
+    };
+
+    await this.observabilityScope.run(
+      {
+        executionId,
+        conversationId: request.conversationId,
+        getStepIndex: () => currentStepIndex,
+        enqueue: enqueueObservabilityTask,
+        appendEvent: async (eventType, data) => {
+          await appendAndProject(eventType, data);
+        },
+      },
+      async () => {
+        try {
+          for await (const event of this.deps.agent.runStream(
+            {
+              executionId,
+              conversationId: request.conversationId,
+              messages: inputMessages,
+              systemPrompt: request.systemPrompt,
+              tools: request.tools,
+              config: request.config,
+              maxSteps: request.maxSteps,
+              abortSignal: request.abortSignal,
+              timeoutBudgetMs: request.timeoutBudgetMs,
+              llmTimeoutRatio: request.llmTimeoutRatio,
+              contextLimitTokens: request.contextLimitTokens,
+            },
+            agentCallbacks
+          )) {
+            const envelope = await appendAndProject(event.type, event.data);
+
+            if (event.type === 'progress' || event.type === 'checkpoint') {
+              const stepIndex = readStepIndex(event.data);
+              if (stepIndex > currentStepIndex) {
+                currentStepIndex = stepIndex;
+              }
+              await this.deps.executionStore.patch(executionId, {
+                stepIndex: currentStepIndex,
+                updatedAt: Date.now(),
+                ...(event.type === 'checkpoint' ? { lastCheckpointSeq: envelope.seq } : {}),
+              });
+            }
+
+            if (event.type === 'compaction') {
+              const contextStore = resolveContextStore(this.deps.messageStore);
+              if (contextStore) {
+                const compaction = extractCompactionInfo(event.data, currentStepIndex);
+                if (compaction.removedMessageIds.length > 0) {
+                  await contextStore.applyCompaction({
+                    conversationId: request.conversationId,
+                    executionId,
+                    stepIndex: compaction.stepIndex,
+                    removedMessageIds: compaction.removedMessageIds,
+                    createdAt: envelope.createdAt,
+                  });
+                }
+              }
+            }
+
+            if (event.type === 'done') {
+              terminalEventSeen = true;
+              const doneData = event.data as {
+                finishReason?: 'stop' | 'max_steps';
+                steps?: number;
+              };
+              finishReason = doneData.finishReason ?? 'stop';
+              if (typeof doneData.steps === 'number' && doneData.steps > 0) {
+                steps = doneData.steps;
+                currentStepIndex = Math.max(currentStepIndex, doneData.steps);
+              }
+            }
+
+            if (event.type === 'error') {
+              terminalEventSeen = true;
+              finishReason = 'error';
+              latestErrorPayload = extractErrorPayload(event.data);
+            }
+          }
+        } catch (error) {
+          streamFailure = error;
+        } finally {
+          this.deps.agent.off('tool_chunk', toolChunkListener);
+          await toolEventQueue;
+          await observabilityQueue;
+        }
+      }
+    );
+
+    if (toolStreamFailure && !streamFailure) {
+      streamFailure = toolStreamFailure;
+    }
+
+    if (streamFailure) {
+      finishReason = 'error';
+      const normalized = normalizeUnknownError(streamFailure);
+      if (!terminalEventSeen) {
+        await appendAndProject('error', normalized);
+      }
+      if (!latestErrorPayload) {
+        latestErrorPayload = normalized;
+      }
+    }
+
+    if (steps === 0) {
+      steps = inferSteps(events);
+    }
+    currentStepIndex = Math.max(currentStepIndex, steps);
+
+    await this.deps.executionStore.patch(
+      executionId,
+      buildTerminalPatch(finishReason, {
+        stepIndex: currentStepIndex,
+        error: latestErrorPayload,
+      })
+    );
+
+    const run = await this.deps.executionStore.get(executionId);
+    if (!run) {
+      throw new Error(`Run not found after completion: ${executionId}`);
+    }
+
+    return {
+      executionId,
+      conversationId: request.conversationId,
+      messages: [...inputMessages, ...emittedMessages],
+      events,
+      finishReason,
+      steps: currentStepIndex,
+      run,
+    };
+  }
+
+  async getRun(executionId: string): Promise<RunRecord | null> {
+    return this.deps.executionStore.get(executionId);
+  }
+
+  async listRuns(conversationId: string, opts?: ListRunsOptions): Promise<ListRunsResult> {
+    return this.deps.executionStore.listByConversation(conversationId, opts);
+  }
+
+  async listRunEvents(executionId: string): Promise<CliEventEnvelope[]> {
+    return this.deps.eventStore.listByRun(executionId);
+  }
+
+  async listContextMessages(conversationId: string): Promise<Message[]> {
+    const contextStore = resolveContextStore(this.deps.messageStore);
+    if (contextStore) {
+      return contextStore.listContext(conversationId);
+    }
+    if (this.deps.messageStore) {
+      return this.deps.messageStore.list(conversationId);
+    }
+    return [];
+  }
+
+  async listDroppedMessages(
+    executionId: string,
+    opts?: { stepIndex?: number; limit?: number }
+  ): Promise<CompactionDroppedMessageRecord[]> {
+    const contextStore = resolveContextStore(this.deps.messageStore);
+    if (!contextStore) {
+      return [];
+    }
+    return contextStore.listDroppedMessages(executionId, opts);
+  }
+
+  async listRunLogs(executionId: string, opts?: { level?: RunLogLevel; limit?: number }) {
+    const runLogStore = resolveRunLogStore(this.deps);
+    if (!runLogStore) {
+      return [];
+    }
+    return runLogStore.listRunLogs(executionId, opts);
+  }
+
+  private createScopedLogger(): AgentLogger {
+    return {
+      debug: (message, context, data) => {
+        this.enqueueRunLog('debug', message, undefined, context, data);
+      },
+      info: (message, context, data) => {
+        this.enqueueRunLog('info', message, undefined, context, data);
+      },
+      warn: (message, context, data) => {
+        this.enqueueRunLog('warn', message, undefined, context, data);
+      },
+      error: (message, error, context) => {
+        this.enqueueRunLog('error', message, error, context);
+      },
+    };
+  }
+
+  private enqueueRunLog(
+    level: RunLogLevel,
+    message: string,
+    error?: unknown,
+    context?: AgentLogContext,
+    data?: unknown
+  ): void {
+    const scope = this.observabilityScope.getStore();
+    const runLogStore = resolveRunLogStore(this.deps);
+    if (!scope || !runLogStore) {
+      return;
+    }
+
+    const payload = buildRunLogPayload({
+      level,
+      message,
+      error,
+      context,
+      data,
+      executionId: scope.executionId,
+      conversationId: scope.conversationId,
+      stepIndex: scope.getStepIndex(),
+    });
+
+    scope.enqueue(async () => {
+      await runLogStore.appendRunLog(payload);
+      await scope.appendEvent('run_log', payload);
+    });
+  }
+}
+
+function buildTerminalPatch(
+  finishReason: RunFinishReason,
+  context: { stepIndex: number; error?: ErrorEventPayload }
+): Partial<RunRecord> {
+  const now = Date.now();
+  const terminalCommon = {
+    updatedAt: now,
+    completedAt: now,
+    stepIndex: context.stepIndex,
+  };
+
+  if (finishReason === 'stop' || finishReason === 'max_steps') {
+    return {
+      ...terminalCommon,
+      status: 'COMPLETED',
+      terminalReason: finishReason,
+    };
+  }
+
+  const mapped = mapErrorPayloadToTerminal(context.error);
+  return {
+    ...terminalCommon,
+    status: mapped.status,
+    terminalReason: mapped.terminalReason,
+    errorCode: context.error?.errorCode,
+    errorCategory: context.error?.category,
+    errorMessage: context.error?.message,
+  };
+}
+
+function mapErrorPayloadToTerminal(error?: ErrorEventPayload): {
+  status: RunRecord['status'];
+  terminalReason: TerminalReason;
+} {
+  switch (error?.errorCode) {
+    case 'AGENT_ABORTED':
+      return { status: 'CANCELLED', terminalReason: 'aborted' };
+    case 'AGENT_TIMEOUT_BUDGET_EXCEEDED':
+    case 'AGENT_UPSTREAM_TIMEOUT':
+      return { status: 'FAILED', terminalReason: 'timeout' };
+    case 'AGENT_UPSTREAM_RATE_LIMIT':
+      return { status: 'FAILED', terminalReason: 'rate_limit' };
+    case 'AGENT_MAX_RETRIES_REACHED':
+      return { status: 'FAILED', terminalReason: 'max_retries' };
+    default:
+      return { status: 'FAILED', terminalReason: 'error' };
+  }
+}
+
+function inferSteps(events: CliEventEnvelope[]): number {
+  let maxStep = 0;
+  for (const event of events) {
+    if (event.eventType !== 'progress' && event.eventType !== 'checkpoint') {
+      continue;
+    }
+    const stepIndex = readStepIndex(event.data);
+    if (stepIndex > maxStep) {
+      maxStep = stepIndex;
+    }
+  }
+  return maxStep;
+}
+
+function readStepIndex(payload: unknown): number {
+  if (!isRecord(payload)) {
+    return 0;
+  }
+  const stepIndex = payload.stepIndex;
+  return typeof stepIndex === 'number' && Number.isFinite(stepIndex) && stepIndex > 0
+    ? stepIndex
+    : 0;
+}
+
+function extractErrorPayload(payload: unknown): ErrorEventPayload | undefined {
+  if (!isRecord(payload)) {
+    return undefined;
+  }
+  return {
+    errorCode: readString(payload.errorCode) ?? readString(payload.code),
+    code: readString(payload.code),
+    category: readString(payload.category),
+    message: readString(payload.message),
+    retryable: readBoolean(payload.retryable),
+    httpStatus: readNumber(payload.httpStatus),
+    name: readString(payload.name),
+  };
+}
+
+function buildRunLogPayload(input: {
+  level: RunLogLevel;
+  message: string;
+  error?: unknown;
+  context?: AgentLogContext;
+  data?: unknown;
+  executionId: string;
+  conversationId: string;
+  stepIndex: number;
+}): RunLogRecord {
+  const errorRecord = toErrorRecord(input.error);
+  const code =
+    readString(input.context?.errorCode) ??
+    readString(errorRecord?.errorCode) ??
+    readString(errorRecord?.code);
+
+  return {
+    executionId: input.executionId,
+    conversationId: input.conversationId,
+    stepIndex: input.stepIndex > 0 ? input.stepIndex : undefined,
+    level: input.level,
+    code: code ?? undefined,
+    source: typeof input.context?.toolName === 'string' ? 'tool' : 'agent',
+    message: input.message,
+    error: errorRecord ?? undefined,
+    context: input.context ? { ...input.context } : undefined,
+    data: input.data,
+    createdAt: Date.now(),
+  };
+}
+
+function toErrorRecord(error: unknown): Record<string, unknown> | undefined {
+  if (!error) {
+    return undefined;
+  }
+  if (error instanceof Error) {
+    const maybeError = error as Error & Record<string, unknown>;
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      ...(typeof error.cause !== 'undefined' ? { cause: error.cause } : {}),
+      ...(readString(maybeError.errorCode) ? { errorCode: readString(maybeError.errorCode) } : {}),
+      ...(readString(maybeError.code) ? { code: readString(maybeError.code) } : {}),
+    };
+  }
+  if (isRecord(error)) {
+    return { ...error };
+  }
+  return { message: String(error) };
+}
+
+function resolveRunLogStore(deps: AgentAppServiceDeps): RunLogStorePort | undefined {
+  if (deps.runLogStore) {
+    return deps.runLogStore;
+  }
+  if (isRunLogStorePort(deps.executionStore)) {
+    return deps.executionStore;
+  }
+  return undefined;
+}
+
+function isRunLogStorePort(value: unknown): value is RunLogStorePort {
+  return (
+    isRecord(value) &&
+    typeof value.appendRunLog === 'function' &&
+    typeof value.listRunLogs === 'function'
+  );
+}
+
+function normalizeUnknownError(error: unknown): ErrorEventPayload {
+  if (isRecord(error)) {
+    const message = readString(error.message) ?? 'Unknown error';
+    return {
+      name: readString(error.name) ?? 'Error',
+      message,
+      errorCode: readString(error.errorCode) ?? readString(error.code) ?? 'UNKNOWN_ERROR',
+      code: readString(error.code),
+      category: readString(error.category),
+      retryable: readBoolean(error.retryable),
+      httpStatus: readNumber(error.httpStatus),
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      errorCode: 'UNKNOWN_ERROR',
+    };
+  }
+  return {
+    name: 'Error',
+    message: String(error),
+    errorCode: 'UNKNOWN_ERROR',
+  };
+}
+
+function createUserMessage(content: MessageContent): Message {
+  return {
+    messageId: createId('msg_usr_'),
+    type: 'user',
+    role: 'user',
+    content,
+    timestamp: Date.now(),
+  };
+}
+
+function createId(prefix: string): string {
+  return `${prefix}${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function readNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function readBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function readUsage(value: unknown): Usage | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+  const promptTokens = readNumber(value.prompt_tokens);
+  const completionTokens = readNumber(value.completion_tokens);
+  const totalTokens = readNumber(value.total_tokens);
+  if (promptTokens === undefined || completionTokens === undefined || totalTokens === undefined) {
+    return undefined;
+  }
+  return {
+    ...value,
+    prompt_tokens: Math.max(0, promptTokens),
+    completion_tokens: Math.max(0, completionTokens),
+    total_tokens: Math.max(0, totalTokens),
+  };
+}
+
+function resolveContextStore(
+  store?: MessageProjectionStorePort
+): ContextProjectionStorePort | undefined {
+  if (
+    store &&
+    typeof (store as ContextProjectionStorePort).listContext === 'function' &&
+    typeof (store as ContextProjectionStorePort).applyCompaction === 'function' &&
+    typeof (store as ContextProjectionStorePort).listDroppedMessages === 'function'
+  ) {
+    return store as ContextProjectionStorePort;
+  }
+  return undefined;
+}
+
+function extractCompactionInfo(
+  payload: unknown,
+  fallbackStepIndex: number
+): { stepIndex: number; removedMessageIds: string[] } {
+  if (!isRecord(payload)) {
+    return { stepIndex: fallbackStepIndex, removedMessageIds: [] };
+  }
+  const rawRemoved = payload.removedMessageIds;
+  const removedMessageIds = Array.isArray(rawRemoved)
+    ? rawRemoved.filter((item): item is string => typeof item === 'string')
+    : [];
+  const stepIndex = readStepIndex(payload);
+  return {
+    stepIndex: stepIndex > 0 ? stepIndex : fallbackStepIndex,
+    removedMessageIds,
+  };
+}
+
+export const AGENT_APP_SERVICE_MODULE = 'renx-app-service';