@renxqoo/renx-code 0.0.3 → 0.0.5

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

@@ -0,0 +1,336 @@
+import type { Tool as ProviderTool } from '../../providers';
+import type { RunRecord } from '../app/contracts';
+import type {
+  RunForegroundCallbacks,
+  RunForegroundRequest,
+  RunForegroundResult,
+} from '../app/agent-app-service';
+import type { Message } from '../types';
+import type { TaskStore } from './task-store';
+import {
+  createAgentId,
+  safeJsonClone,
+  type AgentRunEntity,
+  type AgentRunStatus,
+} from './task-types';
+import type { StartAgentInput, SubagentRunnerAdapter } from './task-runner-adapter';
+import type { ToolExecutionContext } from './types';
+
+interface SubagentExecutionService {
+  runForeground(
+    request: RunForegroundRequest,
+    callbacks?: RunForegroundCallbacks
+  ): Promise<RunForegroundResult>;
+  getRun(executionId: string): Promise<RunRecord | null>;
+  listContextMessages(conversationId: string): Promise<Message[]>;
+}
+
+interface LiveRunState {
+  abortController: AbortController;
+}
+
+interface RunLocator {
+  executionId: string;
+  conversationId: string;
+}
+
+export interface RealSubagentRunnerAdapterOptions {
+  store: TaskStore;
+  appService: SubagentExecutionService;
+  resolveTools?: (allowedTools?: string[]) => ProviderTool[] | undefined;
+  resolveModelId?: (model?: StartAgentInput['model']) => string | undefined;
+  now?: () => number;
+}
+
+export class RealSubagentRunnerAdapter implements SubagentRunnerAdapter {
+  private readonly store: TaskStore;
+  private readonly appService: SubagentExecutionService;
+  private readonly resolveTools?: (allowedTools?: string[]) => ProviderTool[] | undefined;
+  private readonly resolveModelId?: (model?: StartAgentInput['model']) => string | undefined;
+  private readonly now: () => number;
+  private readonly liveRuns = new Map<string, LiveRunState>();
+
+  constructor(options: RealSubagentRunnerAdapterOptions) {
+    this.store = options.store;
+    this.appService = options.appService;
+    this.resolveTools = options.resolveTools;
+    this.resolveModelId = options.resolveModelId;
+    this.now = options.now || Date.now;
+  }
+
+  async start(
+    namespace: string,
+    input: StartAgentInput,
+    context?: ToolExecutionContext
+  ): Promise<AgentRunEntity> {
+    if (input.resume) {
+      const resumed = await this.poll(namespace, input.resume);
+      if (!resumed) {
+        throw new Error(`AGENT_RUN_NOT_FOUND: ${input.resume}`);
+      }
+      return resumed;
+    }
+
+    const now = this.now();
+    const agentId = createAgentId();
+    const locator = this.createLocator(namespace, agentId);
+    const initial: 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: now,
+      startedAt: now,
+      updatedAt: now,
+      progress: 0,
+      metadata: {
+        ...(input.metadata || {}),
+        ...(input.systemPrompt ? { systemPrompt: input.systemPrompt } : {}),
+        executionId: locator.executionId,
+        conversationId: locator.conversationId,
+      },
+      version: 1,
+    };
+
+    const projected = await this.upsertProjection(namespace, initial);
+    await context?.onChunk?.({
+      type: 'info',
+      content: `subagent started: ${agentId}`,
+      data: `subagent started: ${agentId}`,
+    });
+
+    const liveKey = this.liveKey(namespace, agentId);
+    const live = { abortController: new AbortController() };
+    this.liveRuns.set(liveKey, live);
+
+    const runPromise = this.runExecution(namespace, projected, input, live, context);
+    if (input.runInBackground) {
+      void runPromise;
+      return projected;
+    }
+    return runPromise;
+  }
+
+  async poll(namespace: string, agentId: string): Promise<AgentRunEntity | null> {
+    const state = await this.store.getState(namespace);
+    const current = state.agentRuns[agentId];
+    if (!current) {
+      return null;
+    }
+
+    const locator = this.readLocator(current);
+    const remote = await this.appService.getRun(locator.executionId);
+    if (!remote) {
+      return safeJsonClone(current);
+    }
+    if (
+      current.status === 'cancelled' &&
+      (remote.status === 'CREATED' || remote.status === 'QUEUED' || remote.status === 'RUNNING')
+    ) {
+      return safeJsonClone(current);
+    }
+
+    const mapped = this.mapRunRecord(current, remote);
+    if (mapped.status === 'completed' && (!mapped.output || mapped.output.trim().length === 0)) {
+      mapped.output = await this.readCompletionOutput(locator.conversationId);
+    }
+
+    return this.upsertProjection(namespace, mapped);
+  }
+
+  async cancel(
+    namespace: string,
+    agentId: string,
+    reason?: string
+  ): Promise<AgentRunEntity | null> {
+    const key = this.liveKey(namespace, agentId);
+    const live = this.liveRuns.get(key);
+    if (!live) {
+      const existing = await this.poll(namespace, agentId);
+      if (!existing || this.isActive(existing.status)) {
+        return null;
+      }
+      return existing;
+    }
+
+    live.abortController.abort(reason || 'Cancelled by task_stop');
+    const state = await this.store.getState(namespace);
+    const current = state.agentRuns[agentId];
+    if (!current) {
+      return null;
+    }
+
+    const cancelled: AgentRunEntity = {
+      ...safeJsonClone(current),
+      status: 'cancelled',
+      progress: current.progress || 0,
+      error: reason || 'Cancelled by task_stop',
+      endedAt: this.now(),
+      updatedAt: this.now(),
+    };
+    return this.upsertProjection(namespace, cancelled);
+  }
+
+  private async runExecution(
+    namespace: string,
+    initial: AgentRunEntity,
+    input: StartAgentInput,
+    live: LiveRunState,
+    _context?: ToolExecutionContext
+  ): Promise<AgentRunEntity> {
+    const locator = this.readLocator(initial);
+    const request: RunForegroundRequest = {
+      conversationId: locator.conversationId,
+      executionId: locator.executionId,
+      userInput: input.prompt,
+      systemPrompt: input.systemPrompt,
+      maxSteps: input.maxTurns,
+      tools: this.resolveTools?.(input.allowedTools),
+      abortSignal: live.abortController.signal,
+      config: this.buildConfig(input.model),
+    };
+
+    try {
+      const result = await this.appService.runForeground(request);
+      const output = extractAssistantText(result.messages);
+      const mapped = this.mapRunRecord(initial, result.run, output);
+      return await this.upsertProjection(namespace, mapped);
+    } catch (error) {
+      const aborted = live.abortController.signal.aborted;
+      const message = error instanceof Error ? error.message : String(error);
+      const failed: AgentRunEntity = {
+        ...safeJsonClone(initial),
+        status: aborted ? 'cancelled' : 'failed',
+        error: message,
+        progress: aborted ? initial.progress || 0 : initial.progress || 0,
+        endedAt: this.now(),
+        updatedAt: this.now(),
+      };
+      return await this.upsertProjection(namespace, failed);
+    } finally {
+      this.liveRuns.delete(this.liveKey(namespace, initial.agentId));
+    }
+  }
+
+  private mapRunRecord(base: AgentRunEntity, run: RunRecord, output?: string): AgentRunEntity {
+    const status = mapStatus(run);
+    const terminalError = status === 'failed' || status === 'timed_out' || status === 'cancelled';
+    return {
+      ...safeJsonClone(base),
+      status,
+      progress: status === 'completed' ? 100 : base.progress || 0,
+      output: status === 'completed' ? output : undefined,
+      error: terminalError ? run.errorMessage || base.error : undefined,
+      startedAt: run.startedAt || base.startedAt,
+      endedAt: run.completedAt || base.endedAt,
+      updatedAt: run.updatedAt || this.now(),
+      metadata: {
+        ...(base.metadata || {}),
+        terminalReason: run.terminalReason,
+      },
+    };
+  }
+
+  private async upsertProjection(namespace: string, next: AgentRunEntity): Promise<AgentRunEntity> {
+    const result = await this.store.updateState(namespace, (state) => {
+      const existing = state.agentRuns[next.agentId];
+      const mergedMetadata = {
+        ...(existing?.metadata || {}),
+        ...(next.metadata || {}),
+      };
+      const merged: AgentRunEntity = {
+        ...(existing ? safeJsonClone(existing) : {}),
+        ...safeJsonClone(next),
+        metadata: mergedMetadata,
+        version: existing ? existing.version + 1 : 1,
+      };
+      state.agentRuns[next.agentId] = safeJsonClone(merged);
+      return safeJsonClone(merged);
+    });
+    return result.result;
+  }
+
+  private createLocator(namespace: string, agentId: string): RunLocator {
+    return {
+      executionId: agentId,
+      conversationId: `taskns:${namespace}:agent:${agentId}`,
+    };
+  }
+
+  private readLocator(run: AgentRunEntity): RunLocator {
+    const metadata = run.metadata || {};
+    const executionId =
+      typeof metadata.executionId === 'string' ? metadata.executionId : run.agentId;
+    const conversationId =
+      typeof metadata.conversationId === 'string'
+        ? metadata.conversationId
+        : `taskns:default:agent:${run.agentId}`;
+    return { executionId, conversationId };
+  }
+
+  private async readCompletionOutput(conversationId: string): Promise<string | undefined> {
+    try {
+      const messages = await this.appService.listContextMessages(conversationId);
+      return extractAssistantText(messages);
+    } catch {
+      return undefined;
+    }
+  }
+
+  private buildConfig(modelHint?: StartAgentInput['model']): { model?: string } | undefined {
+    const model = this.resolveModelId?.(modelHint);
+    return model ? { model } : undefined;
+  }
+
+  private liveKey(namespace: string, agentId: string): string {
+    return `${namespace}::${agentId}`;
+  }
+
+  private isActive(status: AgentRunStatus): boolean {
+    return status === 'queued' || status === 'running' || status === 'paused';
+  }
+}
+
+function mapStatus(run: RunRecord): AgentRunStatus {
+  switch (run.status) {
+    case 'CREATED':
+    case 'QUEUED':
+      return 'queued';
+    case 'RUNNING':
+      return 'running';
+    case 'COMPLETED':
+      return 'completed';
+    case 'CANCELLED':
+      return 'cancelled';
+    case 'FAILED':
+      return run.terminalReason === 'timeout' ? 'timed_out' : 'failed';
+    default:
+      return 'failed';
+  }
+}
+
+function extractAssistantText(messages: Message[]): string | undefined {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.role !== 'assistant') {
+      continue;
+    }
+    if (typeof message.content === 'string') {
+      const text = message.content.trim();
+      if (text.length > 0) {
+        return text;
+      }
+      continue;
+    }
+    const serialized = JSON.stringify(message.content);
+    if (serialized.length > 0) {
+      return serialized;
+    }
+  }
+  return undefined;
+}

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

@@ -0,0 +1,55 @@
+import type { ToolExecutionContext } from './types';
+import type { AgentRunEntity, SubagentType } from './task-types';
+
+export interface StartAgentInput {
+  subagentType: SubagentType;
+  prompt: string;
+  systemPrompt?: string;
+  description?: string;
+  model?: 'sonnet' | 'opus' | 'haiku';
+  maxTurns?: number;
+  allowedTools?: string[];
+  runInBackground?: boolean;
+  resume?: string;
+  linkedTaskId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface SubagentRunnerAdapter {
+  start(
+    namespace: string,
+    input: StartAgentInput,
+    context?: ToolExecutionContext
+  ): Promise<AgentRunEntity>;
+  poll(namespace: string, agentId: string): Promise<AgentRunEntity | null>;
+  cancel(namespace: string, agentId: string, reason?: string): Promise<AgentRunEntity | null>;
+}
+
+class UnconfiguredSubagentRunnerAdapter implements SubagentRunnerAdapter {
+  async start(): Promise<AgentRunEntity> {
+    throw new Error(
+      'TASK_RUNNER_NOT_CONFIGURED: real subagent runner is required. Inject runner from runtime.'
+    );
+  }
+
+  async poll(): Promise<AgentRunEntity | null> {
+    return null;
+  }
+
+  async cancel(): Promise<AgentRunEntity | null> {
+    return null;
+  }
+}
+
+export function createUnconfiguredSubagentRunnerAdapter(): SubagentRunnerAdapter {
+  return new UnconfiguredSubagentRunnerAdapter();
+}
+
+export {
+  InProcessMockRunnerAdapter,
+  type InProcessMockRunnerAdapterOptions,
+} from './task-mock-runner-adapter';
+export {
+  RealSubagentRunnerAdapter,
+  type RealSubagentRunnerAdapterOptions,
+} from './task-real-runner-adapter';

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

@@ -0,0 +1,187 @@
+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 } from './task-types';
+import { TASK_STOP_DESCRIPTION } from './tool-prompts';
+
+const cancelLinkedTaskSchema = 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 stop'),
+    task_id: z
+      .string()
+      .min(1)
+      .optional()
+      .describe('Planning task id used to resolve linked agent run'),
+    reason: z.string().optional().describe('Optional cancellation reason'),
+    cancel_linked_task: cancelLinkedTaskSchema
+      .optional()
+      .describe('When true, also cancel linked planning tasks'),
+  })
+  .strict();
+
+type TaskStopArgs = z.infer<typeof schema>;
+
+export interface TaskStopToolOptions {
+  store?: TaskStore;
+  runner?: SubagentRunnerAdapter;
+  defaultNamespace?: string;
+}
+
+export class TaskStopTool extends BaseTool<typeof schema> {
+  name = 'task_stop';
+  description = TASK_STOP_DESCRIPTION;
+  parameters = schema;
+
+  private readonly store: TaskStore;
+  private readonly runner: SubagentRunnerAdapter;
+  private readonly defaultNamespace?: string;
+
+  constructor(options: TaskStopToolOptions = {}) {
+    super();
+    this.store = options.store || getTaskStore();
+    this.runner = options.runner || createUnconfiguredSubagentRunnerAdapter();
+    this.defaultNamespace = options.defaultNamespace;
+  }
+
+  override getConcurrencyMode(): 'exclusive' {
+    return 'exclusive';
+  }
+
+  override getConcurrencyLockKey(args: TaskStopArgs): string {
+    const namespace = args.namespace || this.defaultNamespace || 'default';
+    return `taskns:${namespace}`;
+  }
+
+  async execute(args: TaskStopArgs): Promise<ToolResult> {
+    const namespace = args.namespace || this.defaultNamespace;
+    const normalizedNamespace = this.store.normalizeNamespace(namespace);
+
+    const resolved = await this.resolveAgentId(normalizedNamespace, args);
+    if (!resolved.ok) {
+      return buildTaskFailure(resolved.code, resolved.message, {
+        namespace: normalizedNamespace,
+      });
+    }
+
+    const agentId = resolved.agentId;
+    const before = await this.runner.poll(normalizedNamespace, agentId);
+    if (!before) {
+      return buildTaskFailure('AGENT_RUN_NOT_FOUND', `agent run not found: ${agentId}`, {
+        namespace: normalizedNamespace,
+      });
+    }
+    if (isAgentRunTerminal(before.status)) {
+      return buildTaskFailure(
+        'AGENT_RUN_ALREADY_TERMINAL',
+        `agent run already terminal: ${before.status}`,
+        {
+          namespace: normalizedNamespace,
+          agent_id: agentId,
+        }
+      );
+    }
+
+    const cancelled = await this.runner.cancel(normalizedNamespace, agentId, args.reason);
+    if (!cancelled) {
+      return buildTaskFailure('AGENT_RUN_NOT_FOUND', `agent run not found: ${agentId}`, {
+        namespace: normalizedNamespace,
+      });
+    }
+
+    const affectedTaskIds: string[] = [];
+    const cancelLinkedTask = args.cancel_linked_task !== undefined ? args.cancel_linked_task : true;
+
+    if (cancelLinkedTask) {
+      const updated = await this.store.updateState(normalizedNamespace, (state) => {
+        const now = Date.now();
+        const targets = Object.values(state.tasks).filter((task) => task.agentId === agentId);
+
+        for (const task of targets) {
+          if (task.status === 'completed' || task.status === 'cancelled') {
+            continue;
+          }
+          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_stop',
+            reason: args.reason || 'Cancelled by task_stop',
+            metadata: {
+              agentId,
+            },
+          });
+          affectedTaskIds.push(task.id);
+        }
+        return null;
+      });
+      void updated;
+    }
+
+    return buildTaskSuccess({
+      namespace: normalizedNamespace,
+      agent_run: safeJsonClone(cancelled),
+      cancelled_task_ids: affectedTaskIds,
+    });
+  }
+
+  private async resolveAgentId(
+    namespace: string,
+    args: TaskStopArgs
+  ): 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_STOP_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 TaskStopTool;