@renxqoo/renx-code 0.0.9 → 0.0.10

package/vendor/agent-root/src/agent/tool/task-mock-runner-adapter.ts

@@ -1,232 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import type { ToolExecutionContext } from './types';
-import { TaskStore } from './task-store';
-import {
-  createAgentId,
-  isAgentRunTerminal,
-  safeJsonClone,
-  type AgentRunEntity,
-} from './task-types';
-import type { StartAgentInput, SubagentRunnerAdapter } from './task-runner-adapter';
-
-export interface InProcessMockRunnerAdapterOptions {
-  completionDelayMs?: number;
-  now?: () => number;
-}
-
-function createMockOutput(run: AgentRunEntity): string {
-  const preview = run.prompt.trim().slice(0, 120);
-  if (!preview) {
-    return `Subagent ${run.agentId} completed`;
-  }
-  return `Subagent ${run.agentId} completed: ${preview}`;
-}
-
-export class InProcessMockRunnerAdapter implements SubagentRunnerAdapter {
-  private readonly completionDelayMs: number;
-  private readonly now: () => number;
-  private readonly timers = new Map<string, NodeJS.Timeout>();
-
-  constructor(
-    private readonly store: TaskStore,
-    options: InProcessMockRunnerAdapterOptions = {}
-  ) {
-    this.completionDelayMs =
-      typeof options.completionDelayMs === 'number' && options.completionDelayMs > 0
-        ? options.completionDelayMs
-        : 30;
-    this.now = options.now || Date.now;
-  }
-
-  async start(
-    namespace: string,
-    input: StartAgentInput,
-    context?: ToolExecutionContext
-  ): Promise<AgentRunEntity> {
-    if (input.resume) {
-      const resumed = await this.resumeRun(namespace, input.resume);
-      if (!resumed) {
-        throw new Error(`AGENT_RUN_NOT_FOUND: ${input.resume}`);
-      }
-      return resumed;
-    }
-
-    const createdAt = this.now();
-    const agentId = createAgentId();
-    const outputFile = this.buildOutputFilePath(namespace, agentId);
-    const run: AgentRunEntity = {
-      agentId,
-      status: 'running',
-      subagentType: input.subagentType,
-      prompt: input.prompt,
-      description: input.description,
-      model: input.model,
-      maxTurns: input.maxTurns,
-      allowedTools: input.allowedTools,
-      linkedTaskId: input.linkedTaskId,
-      createdAt,
-      startedAt: createdAt,
-      updatedAt: createdAt,
-      progress: input.runInBackground ? 0 : 100,
-      outputFile: input.runInBackground ? outputFile : undefined,
-      metadata: {
-        ...(input.metadata || {}),
-        ...(input.systemPrompt ? { systemPrompt: input.systemPrompt } : {}),
-      },
-      version: 1,
-    };
-
-    await this.store.updateState(namespace, (state) => {
-      state.agentRuns[run.agentId] = safeJsonClone(run);
-      return null;
-    });
-
-    await context?.onChunk?.({
-      type: 'info',
-      content: `subagent started: ${run.agentId}`,
-      data: `subagent started: ${run.agentId}`,
-    });
-
-    if (input.runInBackground) {
-      this.scheduleCompletion(namespace, run.agentId);
-      return run;
-    }
-
-    const completed = await this.completeRun(namespace, run.agentId);
-    return completed || run;
-  }
-
-  async poll(namespace: string, agentId: string): Promise<AgentRunEntity | null> {
-    const state = await this.store.getState(namespace);
-    return safeJsonClone(state.agentRuns[agentId] || null);
-  }
-
-  async cancel(
-    namespace: string,
-    agentId: string,
-    reason?: string
-  ): Promise<AgentRunEntity | null> {
-    const timerKey = this.timerKey(namespace, agentId);
-    const timer = this.timers.get(timerKey);
-    if (timer) {
-      clearTimeout(timer);
-      this.timers.delete(timerKey);
-    }
-
-    const result = await this.store.updateState(namespace, (state) => {
-      const run = state.agentRuns[agentId];
-      if (!run) {
-        return null;
-      }
-      if (isAgentRunTerminal(run.status)) {
-        return safeJsonClone(run);
-      }
-      run.status = 'cancelled';
-      run.error = reason || 'Cancelled by task_stop';
-      run.progress = run.progress || 0;
-      run.endedAt = this.now();
-      run.updatedAt = this.now();
-      run.version += 1;
-      return safeJsonClone(run);
-    });
-    return result.result;
-  }
-
-  private async resumeRun(namespace: string, resumeId: string): Promise<AgentRunEntity | null> {
-    const result = await this.store.updateState(namespace, (state) => {
-      const run = state.agentRuns[resumeId];
-      if (!run) {
-        return null;
-      }
-      if (isAgentRunTerminal(run.status) || run.status === 'running') {
-        return safeJsonClone(run);
-      }
-      run.status = 'running';
-      run.updatedAt = this.now();
-      run.version += 1;
-      return safeJsonClone(run);
-    });
-    const resumed = result.result;
-    if (resumed && resumed.status === 'running') {
-      this.scheduleCompletion(namespace, resumed.agentId);
-    }
-    return resumed;
-  }
-
-  private scheduleCompletion(namespace: string, agentId: string): void {
-    const timerKey = this.timerKey(namespace, agentId);
-    const existing = this.timers.get(timerKey);
-    if (existing) {
-      clearTimeout(existing);
-    }
-    const timer = setTimeout(() => {
-      void this.completeRun(namespace, agentId);
-    }, this.completionDelayMs);
-    this.timers.set(timerKey, timer);
-  }
-
-  private async completeRun(namespace: string, agentId: string): Promise<AgentRunEntity | null> {
-    const timerKey = this.timerKey(namespace, agentId);
-    const timer = this.timers.get(timerKey);
-    if (timer) {
-      clearTimeout(timer);
-      this.timers.delete(timerKey);
-    }
-
-    const result = await this.store.updateState(namespace, (state) => {
-      const run = state.agentRuns[agentId];
-      if (!run) {
-        return null;
-      }
-      if (isAgentRunTerminal(run.status)) {
-        return safeJsonClone(run);
-      }
-
-      const prompt = run.prompt.toLowerCase();
-      if (prompt.includes('[task_fail]')) {
-        run.status = 'failed';
-        run.error = 'Subagent mock failure requested by prompt token [TASK_FAIL]';
-      } else if (prompt.includes('[task_pause]')) {
-        run.status = 'paused';
-      } else if (prompt.includes('[task_timeout]')) {
-        run.status = 'timed_out';
-        run.error = 'Subagent mock timeout requested by prompt token [TASK_TIMEOUT]';
-      } else {
-        run.status = 'completed';
-        run.output = createMockOutput(run);
-      }
-
-      run.progress = run.status === 'completed' ? 100 : run.progress || 0;
-      run.endedAt = this.now();
-      run.updatedAt = this.now();
-      run.version += 1;
-
-      return safeJsonClone(run);
-    });
-
-    const completed = result.result;
-    if (completed?.outputFile) {
-      await this.persistOutputFile(completed.outputFile, completed);
-    }
-    return completed;
-  }
-
-  private async persistOutputFile(outputFile: string, run: AgentRunEntity): Promise<void> {
-    try {
-      await fs.mkdir(path.dirname(outputFile), { recursive: true });
-      const content = run.output || run.error || run.status;
-      await fs.writeFile(outputFile, content, 'utf8');
-    } catch {
-      // Persisting debug output must never block tool response.
-    }
-  }
-
-  private buildOutputFilePath(namespace: string, agentId: string): string {
-    return path.join(this.store.baseDir, 'logs', namespace, `${agentId}.log`);
-  }
-
-  private timerKey(namespace: string, agentId: string): string {
-    return `${namespace}::${agentId}`;
-  }
-}

package/vendor/agent-root/src/agent/tool/task-output.ts

@@ -1,223 +0,0 @@
-import { z } from 'zod';
-import { BaseTool, type ToolResult } from './base-tool';
-import { buildTaskFailure, buildTaskSuccess } from './task-errors';
-import { getTaskStore, type TaskStore } from './task-store';
-import {
-  createUnconfiguredSubagentRunnerAdapter,
-  type SubagentRunnerAdapter,
-} from './task-runner-adapter';
-import { isAgentRunTerminal, safeJsonClone, type AgentRunEntity } from './task-types';
-import type { ToolExecutionContext } from './types';
-import { TASK_OUTPUT_DESCRIPTION } from './tool-prompts';
-
-const blockSchema = z.preprocess((value) => {
-  if (typeof value === 'string') {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'true') return true;
-    if (normalized === 'false') return false;
-  }
-  return value;
-}, z.boolean());
-
-const schema = z
-  .object({
-    namespace: z.string().min(1).optional().describe('Optional task namespace'),
-    agent_id: z.string().min(1).optional().describe('Direct agent run id to query'),
-    task_id: z
-      .string()
-      .min(1)
-      .optional()
-      .describe('Planning task id used to resolve linked agent run'),
-    block: blockSchema.optional().describe('Wait for task completion before returning'),
-    timeout_ms: z
-      .number()
-      .int()
-      .min(1)
-      .max(30 * 60 * 1000)
-      .optional()
-      .describe('Timeout in milliseconds when blocking'),
-    poll_interval_ms: z
-      .number()
-      .int()
-      .min(20)
-      .max(5000)
-      .optional()
-      .describe('Polling interval in milliseconds'),
-  })
-  .strict();
-
-type TaskOutputArgs = z.infer<typeof schema>;
-
-export interface TaskOutputToolOptions {
-  store?: TaskStore;
-  runner?: SubagentRunnerAdapter;
-  defaultNamespace?: string;
-}
-
-async function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  if (signal?.aborted) {
-    throw new Error('TASK_OUTPUT_ABORTED: polling aborted');
-  }
-  await new Promise<void>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      signal?.removeEventListener('abort', onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timeout);
-      reject(new Error('TASK_OUTPUT_ABORTED: polling aborted'));
-    };
-    signal?.addEventListener('abort', onAbort, { once: true });
-  });
-}
-
-function sanitizeTaskOutputRun(run: AgentRunEntity): AgentRunEntity {
-  const cloned = safeJsonClone(run);
-  if (cloned.status === 'completed') {
-    return cloned;
-  }
-
-  delete cloned.output;
-
-  if (
-    (cloned.status === 'failed' ||
-      cloned.status === 'timed_out' ||
-      cloned.status === 'cancelled') &&
-    (!cloned.error || cloned.error.trim().length === 0)
-  ) {
-    cloned.error = `Agent run ${cloned.status}`;
-  }
-
-  return cloned;
-}
-
-export class TaskOutputTool extends BaseTool<typeof schema> {
-  name = 'task_output';
-  description = TASK_OUTPUT_DESCRIPTION;
-  parameters = schema;
-
-  private readonly store: TaskStore;
-  private readonly runner: SubagentRunnerAdapter;
-  private readonly defaultNamespace?: string;
-
-  constructor(options: TaskOutputToolOptions = {}) {
-    super();
-    this.store = options.store || getTaskStore();
-    this.runner = options.runner || createUnconfiguredSubagentRunnerAdapter();
-    this.defaultNamespace = options.defaultNamespace;
-  }
-
-  override getConcurrencyMode(): 'parallel-safe' {
-    return 'parallel-safe';
-  }
-
-  override getConcurrencyLockKey(args: TaskOutputArgs): string {
-    const namespace = args.namespace || this.defaultNamespace || 'default';
-    const target = args.agent_id || args.task_id || 'unknown';
-    return `taskns:${namespace}:agent:${target}`;
-  }
-
-  async execute(args: TaskOutputArgs, context?: ToolExecutionContext): Promise<ToolResult> {
-    const namespace = args.namespace || this.defaultNamespace;
-    const normalizedNamespace = this.store.normalizeNamespace(namespace);
-
-    const resolvedAgentIdResult = await this.resolveAgentId(normalizedNamespace, args);
-    if (!resolvedAgentIdResult.ok) {
-      return buildTaskFailure(resolvedAgentIdResult.code, resolvedAgentIdResult.message, {
-        namespace: normalizedNamespace,
-      });
-    }
-
-    const agentId = resolvedAgentIdResult.agentId;
-
-    const shouldBlock = args.block !== undefined ? args.block : true;
-    const timeoutMs = args.timeout_ms !== undefined ? args.timeout_ms : 30000;
-    const pollIntervalMs = args.poll_interval_ms !== undefined ? args.poll_interval_ms : 200;
-
-    // Default semantics: block=true.
-    if (!shouldBlock) {
-      const run = await this.runner.poll(normalizedNamespace, agentId);
-      if (!run) {
-        return buildTaskFailure('AGENT_RUN_NOT_FOUND', `agent run not found: ${agentId}`, {
-          namespace: normalizedNamespace,
-        });
-      }
-      return buildTaskSuccess({
-        namespace: normalizedNamespace,
-        agent_run: sanitizeTaskOutputRun(run),
-      });
-    }
-
-    const startedAt = Date.now();
-    while (Date.now() - startedAt < timeoutMs) {
-      const run = await this.runner.poll(normalizedNamespace, agentId);
-      if (!run) {
-        return buildTaskFailure('AGENT_RUN_NOT_FOUND', `agent run not found: ${agentId}`, {
-          namespace: normalizedNamespace,
-        });
-      }
-      if (isAgentRunTerminal(run.status)) {
-        return buildTaskSuccess({
-          namespace: normalizedNamespace,
-          agent_run: sanitizeTaskOutputRun(run),
-          waited_ms: Date.now() - startedAt,
-          completed: true,
-        });
-      }
-      await sleep(pollIntervalMs, context?.toolAbortSignal);
-    }
-
-    const latest = await this.runner.poll(normalizedNamespace, agentId);
-    if (!latest) {
-      return buildTaskFailure('AGENT_RUN_NOT_FOUND', `agent run not found: ${agentId}`, {
-        namespace: normalizedNamespace,
-      });
-    }
-    return buildTaskSuccess({
-      namespace: normalizedNamespace,
-      agent_run: sanitizeTaskOutputRun(latest),
-      waited_ms: Date.now() - startedAt,
-      completed: false,
-      timeout_hit: true,
-    });
-  }
-
-  private async resolveAgentId(
-    namespace: string,
-    args: TaskOutputArgs
-  ): Promise<{ ok: true; agentId: string } | { ok: false; code: string; message: string }> {
-    if (args.agent_id) {
-      return { ok: true, agentId: args.agent_id };
-    }
-    if (!args.task_id) {
-      return {
-        ok: false,
-        code: 'TASK_OUTPUT_TARGET_REQUIRED',
-        message: 'agent_id or task_id is required',
-      };
-    }
-
-    const state = await this.store.getState(namespace);
-    const task = state.tasks[args.task_id];
-    if (!task) {
-      return {
-        ok: false,
-        code: 'TASK_NOT_FOUND',
-        message: `task not found: ${args.task_id}`,
-      };
-    }
-    if (!task.agentId) {
-      return {
-        ok: false,
-        code: 'AGENT_RUN_NOT_FOUND',
-        message: `task has no linked agent run: ${args.task_id}`,
-      };
-    }
-    return {
-      ok: true,
-      agentId: task.agentId,
-    };
-  }
-}
-
-export default TaskOutputTool;

package/vendor/agent-root/src/agent/tool/task-parent-abort.ts

@@ -1,115 +0,0 @@
-import type { SubagentRunnerAdapter } from './task-runner-adapter';
-import type { TaskStore } from './task-store';
-import type { ToolExecutionContext } from './types';
-
-export const PARENT_ABORT_REASON = 'Cancelled by parent agent abort';
-
-interface ParentAbortCascadeParams {
-  context?: ToolExecutionContext;
-  namespace: string;
-  agentId: string;
-  linkedTaskId?: string;
-  runner: SubagentRunnerAdapter;
-  store: TaskStore;
-}
-
-interface CancelLinkedTaskParams {
-  namespace: string;
-  linkedTaskId: string;
-  agentId: string;
-  agentStatus: string;
-  store: TaskStore;
-}
-
-export function attachParentAbortCascade(params: ParentAbortCascadeParams): () => void {
-  const signal = params.context?.toolAbortSignal;
-  if (!signal) {
-    return () => {};
-  }
-
-  let settled = false;
-  const onAbort = () => {
-    if (settled) {
-      return;
-    }
-    settled = true;
-    void onParentAborted(params);
-  };
-
-  signal.addEventListener('abort', onAbort, { once: true });
-  if (signal.aborted) {
-    onAbort();
-  }
-
-  return () => {
-    signal.removeEventListener('abort', onAbort);
-  };
-}
-
-async function onParentAborted(params: ParentAbortCascadeParams): Promise<void> {
-  try {
-    const cancelled = await params.runner.cancel(
-      params.namespace,
-      params.agentId,
-      PARENT_ABORT_REASON
-    );
-    await params.context?.onChunk?.({
-      type: 'info',
-      content: `subagent cancelled by parent abort: ${params.agentId}`,
-      data: `subagent cancelled by parent abort: ${params.agentId}`,
-    });
-
-    if (cancelled?.status === 'cancelled' && params.linkedTaskId) {
-      await cancelLinkedTaskOnParentAbort({
-        namespace: params.namespace,
-        linkedTaskId: params.linkedTaskId,
-        agentId: params.agentId,
-        agentStatus: cancelled.status,
-        store: params.store,
-      });
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    await params.context?.onChunk?.({
-      type: 'stderr',
-      content: `failed to cascade parent abort: ${message}`,
-      data: `failed to cascade parent abort: ${message}`,
-    });
-  }
-}
-
-async function cancelLinkedTaskOnParentAbort(params: CancelLinkedTaskParams): Promise<void> {
-  await params.store.updateState(params.namespace, (state) => {
-    const task = state.tasks[params.linkedTaskId];
-    if (!task) {
-      return null;
-    }
-    if (task.agentId && task.agentId !== params.agentId) {
-      return null;
-    }
-    if (task.status === 'completed' || task.status === 'cancelled') {
-      return null;
-    }
-
-    const now = Date.now();
-    const previousStatus = task.status;
-    task.status = 'cancelled';
-    task.owner = null;
-    task.cancelledAt = now;
-    task.updatedAt = now;
-    task.version += 1;
-    task.history.push({
-      timestamp: now,
-      action: 'cancelled',
-      fromStatus: previousStatus,
-      toStatus: 'cancelled',
-      actor: 'task-parent-abort',
-      reason: PARENT_ABORT_REASON,
-      metadata: {
-        agentId: params.agentId,
-        agentStatus: params.agentStatus,
-      },
-    });
-    return null;
-  });
-}