@renxqoo/renx-code 0.0.9 → 0.0.12

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

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

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

@@ -1,187 +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 } 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;