@renxqoo/renx-code 0.0.4 → 0.0.5

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

@@ -0,0 +1,109 @@
+import type { StreamEvent } from '../types';
+
+export type RunStatus = 'CREATED' | 'QUEUED' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED';
+
+export type TerminalReason =
+  | 'stop'
+  | 'max_steps'
+  | 'error'
+  | 'aborted'
+  | 'timeout'
+  | 'rate_limit'
+  | 'max_retries';
+
+export interface RunRecord {
+  executionId: string;
+  runId: string;
+  conversationId: string;
+  status: RunStatus;
+  createdAt: number;
+  updatedAt: number;
+  stepIndex: number;
+  startedAt?: number;
+  completedAt?: number;
+  lastCheckpointSeq?: number;
+  terminalReason?: TerminalReason;
+  errorCode?: string;
+  errorCategory?: string;
+  errorMessage?: string;
+}
+
+export interface ExecutionStepRecord {
+  executionId: string;
+  stepIndex: number;
+  status: 'pending' | 'executing' | 'completed' | 'failed' | 'skipped';
+  stage?: 'llm' | 'tool' | 'checkpoint';
+  errorCode?: string;
+  startedAt?: number;
+  completedAt?: number;
+}
+
+export type RunLogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+export interface RunLogRecord {
+  id?: number;
+  executionId: string;
+  conversationId: string;
+  stepIndex?: number;
+  level: RunLogLevel;
+  code?: string;
+  source: string;
+  message: string;
+  error?: Record<string, unknown>;
+  context?: Record<string, unknown>;
+  data?: unknown;
+  createdAt: number;
+}
+
+export interface ListRunLogsOptions {
+  level?: RunLogLevel;
+  limit?: number;
+}
+
+export type CliEventType =
+  | StreamEvent['type']
+  | 'user_message'
+  | 'assistant_message'
+  | 'metric'
+  | 'trace'
+  | 'run_log';
+
+export interface CliEvent {
+  type: CliEventType;
+  data: unknown;
+}
+
+export interface CliEventEnvelope {
+  conversationId: string;
+  executionId: string;
+  seq: number;
+  eventType: CliEventType;
+  data: unknown;
+  createdAt: number;
+}
+
+export interface ListRunsOptions {
+  statuses?: RunStatus[];
+  limit?: number;
+  cursor?: string;
+}
+
+export interface ListRunsResult {
+  items: RunRecord[];
+  nextCursor?: string;
+}
+
+export interface ListConversationEventsOptions {
+  fromSeq?: number;
+  limit?: number;
+}
+
+export interface CompactionDroppedMessageRecord {
+  conversationId: string;
+  executionId: string;
+  stepIndex: number;
+  removedMessageId: string;
+  createdAt: number;
+}
+
+export const AGENT_APP_CONTRACTS_MODULE = 'renx-app-contracts';

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

@@ -0,0 +1,5 @@
+export * from './contracts';
+export * from './ports';
+export * from './minimal-agent-application';
+export * from './agent-app-service';
+export * from './sqlite-agent-app-store';

package/vendor/agent-root/src/agent/app/minimal-agent-application.ts

@@ -0,0 +1,151 @@
+import type { LLMGenerateOptions, Tool } from '../../providers';
+import { StatelessAgent } from '../agent';
+import type { AgentCallbacks, Message, StreamEvent } from '../types';
+
+type RunFinishReason = 'stop' | 'max_steps' | 'error';
+
+export interface RunAgentRequest {
+  conversationId: string;
+  userInput: string;
+  executionId?: string;
+  historyMessages?: Message[];
+  systemPrompt?: string;
+  tools?: Tool[];
+  config?: LLMGenerateOptions;
+  maxSteps?: number;
+  abortSignal?: AbortSignal;
+  timeoutBudgetMs?: number;
+  llmTimeoutRatio?: number;
+}
+
+export interface RunAgentCallbacks extends Partial<AgentCallbacks> {
+  onToolStream?: (event: StreamEvent) => void | Promise<void>;
+  onEvent?: (event: StreamEvent) => void | Promise<void>;
+}
+
+export interface RunAgentResult {
+  executionId: string;
+  conversationId: string;
+  messages: Message[];
+  events: StreamEvent[];
+  finishReason: RunFinishReason;
+  steps: number;
+}
+
+export class MinimalStatelessAgentApplication {
+  constructor(private readonly agent: StatelessAgent) {}
+
+  async runForeground(
+    request: RunAgentRequest,
+    callbacks?: RunAgentCallbacks
+  ): Promise<RunAgentResult> {
+    const executionId = request.executionId ?? createId('exec_');
+    const baseMessages = request.historyMessages ? [...request.historyMessages] : [];
+    const userMessage = createUserMessage(request.userInput);
+    const inputMessages = [...baseMessages, userMessage];
+    const emittedMessages: Message[] = [];
+    const events: StreamEvent[] = [];
+    let finishReason: RunFinishReason = 'error';
+    let steps = 0;
+
+    const toolChunkListener = (payload: unknown): void => {
+      const toolStreamEvent: StreamEvent = {
+        type: 'tool_stream',
+        data: payload,
+      };
+      events.push(toolStreamEvent);
+      void callbacks?.onToolStream?.(toolStreamEvent);
+      void callbacks?.onEvent?.(toolStreamEvent);
+    };
+
+    this.agent.on('tool_chunk', toolChunkListener);
+
+    const agentCallbacks: AgentCallbacks = {
+      onMessage: async (message) => {
+        emittedMessages.push(message);
+        await callbacks?.onMessage?.(message);
+      },
+      onCheckpoint: async (checkpoint) => {
+        await callbacks?.onCheckpoint?.(checkpoint);
+      },
+      onProgress: callbacks?.onProgress,
+      onCompaction: callbacks?.onCompaction,
+      onMetric: callbacks?.onMetric,
+      onTrace: callbacks?.onTrace,
+      onToolPolicy: callbacks?.onToolPolicy,
+      onError: callbacks?.onError,
+    };
+
+    try {
+      for await (const event of this.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,
+        },
+        agentCallbacks
+      )) {
+        events.push(event);
+        await callbacks?.onEvent?.(event);
+        if (event.type === 'done') {
+          const doneData = event.data as { finishReason?: 'stop' | 'max_steps'; steps?: number };
+          finishReason = doneData.finishReason ?? 'stop';
+          steps = typeof doneData.steps === 'number' ? doneData.steps : steps;
+        }
+        if (event.type === 'error') {
+          finishReason = 'error';
+        }
+      }
+    } finally {
+      this.agent.off('tool_chunk', toolChunkListener);
+    }
+
+    if (steps === 0) {
+      steps = inferSteps(events);
+    }
+
+    return {
+      executionId,
+      conversationId: request.conversationId,
+      messages: [...inputMessages, ...emittedMessages],
+      events,
+      finishReason,
+      steps,
+    };
+  }
+}
+
+function inferSteps(events: StreamEvent[]): number {
+  let maxStep = 0;
+  for (const event of events) {
+    if (event.type !== 'progress' && event.type !== 'checkpoint') {
+      continue;
+    }
+    const data = event.data as { stepIndex?: number };
+    if (typeof data.stepIndex === 'number' && data.stepIndex > maxStep) {
+      maxStep = data.stepIndex;
+    }
+  }
+  return maxStep;
+}
+
+function createUserMessage(content: string): 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)}`;
+}

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

@@ -0,0 +1,72 @@
+import type { Tool } from '../../providers';
+import type { ToolExecutionLedger } from '../agent';
+import type { Message } from '../types';
+import type {
+  CliEvent,
+  CliEventEnvelope,
+  CompactionDroppedMessageRecord,
+  ListConversationEventsOptions,
+  ListRunLogsOptions,
+  ListRunsOptions,
+  ListRunsResult,
+  RunRecord,
+  RunLogRecord,
+} from './contracts';
+
+export interface ExecutionStorePort {
+  create(run: RunRecord): Promise<void>;
+  patch(executionId: string, patch: Partial<RunRecord>): Promise<void>;
+  get(executionId: string): Promise<RunRecord | null>;
+  listByConversation(conversationId: string, opts?: ListRunsOptions): Promise<ListRunsResult>;
+}
+
+export interface EventStorePort {
+  appendAutoSeq(event: Omit<CliEventEnvelope, 'seq'>): Promise<CliEventEnvelope>;
+  append(event: CliEventEnvelope): Promise<void>;
+  listByRun(executionId: string): Promise<CliEventEnvelope[]>;
+  listEventsByConversation(
+    conversationId: string,
+    opts?: ListConversationEventsOptions
+  ): Promise<CliEventEnvelope[]>;
+}
+
+export interface MessageProjectionStorePort {
+  upsertFromEvent(event: CliEventEnvelope): Promise<void>;
+  list(conversationId: string): Promise<Message[]>;
+}
+
+export interface ContextProjectionStorePort extends MessageProjectionStorePort {
+  listContext(conversationId: string): Promise<Message[]>;
+  applyCompaction(input: {
+    conversationId: string;
+    executionId: string;
+    stepIndex: number;
+    removedMessageIds: string[];
+    createdAt: number;
+  }): Promise<void>;
+  listDroppedMessages(
+    executionId: string,
+    opts?: { stepIndex?: number; limit?: number }
+  ): Promise<CompactionDroppedMessageRecord[]>;
+}
+
+export interface RunLogStorePort {
+  appendRunLog(record: RunLogRecord): Promise<void>;
+  listRunLogs(executionId: string, opts?: ListRunLogsOptions): Promise<RunLogRecord[]>;
+}
+
+export interface ContextProviderPort {
+  load(
+    conversationId: string
+  ): Promise<{ messages: Message[]; systemPrompt?: string; tools?: Tool[] }>;
+}
+
+export interface EventSinkPort {
+  publish(executionId: string, event: CliEvent): Promise<void>;
+}
+
+export interface LedgerProviderPort {
+  getLedger(conversationId: string): ToolExecutionLedger;
+}
+
+export const AGENT_APP_PORTS_MODULE = 'renx-app-ports';