@renxqoo/renx-code 0.0.3 → 0.0.5

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

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

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

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