@downcity/agent 1.1.1

package/src/services/task/runtime/TaskRunnerRound.ts

@@ -0,0 +1,337 @@
+/**
+ * TaskRunnerRound：task runner 单轮执行与输出解析模块。
+ *
+ * 关键点（中文）
+ * - 收敛 agent/script 单轮执行、assistant 输出提取、模拟用户判定解析等逻辑。
+ * - 这些逻辑可独立演进，不必与 run 目录产物写入混在一起。
+ */
+
+import path from "node:path";
+import fs from "fs-extra";
+import { stripInvocationAuthEnv } from "@/http/auth/AuthEnv.js";
+import type { AgentContext } from "@/types/agent/AgentContext.js";
+import { runSandboxCommand } from "@/sandbox/SandboxRunner.js";
+import type { SessionRunResult } from "@/types/session/SessionRun.js";
+import type { JsonObject } from "@/shared/types/Json.js";
+import type {
+  ChatSendOutputPick,
+  ScriptExecutionResult,
+  TaskResultValidation,
+  TaskSessionRuntimePort,
+  UserSimulatorDecision,
+} from "@/types/task/TaskRunner.js";
+import { withSessionRunScope } from "@session/SessionRunScope.js";
+import { appendTaskRoundUserMessage } from "./TaskRunnerSession.js";
+
+/**
+ * 从文本中提取 JSON 对象（支持 ```json 代码块）。
+ */
+export function tryExtractJsonObject(text: string): JsonObject | null {
+  const raw = String(text ?? "").trim();
+  if (!raw) return null;
+
+  const tryParse = (s: string): JsonObject | null => {
+    try {
+      const parsed = JSON.parse(s);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed as JsonObject;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  };
+
+  const direct = tryParse(raw);
+  if (direct) return direct;
+
+  const fenced = raw.match(/```json\s*([\s\S]*?)\s*```/i);
+  if (fenced?.[1]) {
+    const parsed = tryParse(fenced[1].trim());
+    if (parsed) return parsed;
+  }
+
+  const loose = raw.match(/\{[\s\S]*\}/);
+  if (loose?.[0]) {
+    const parsed = tryParse(loose[0]);
+    if (parsed) return parsed;
+  }
+
+  return null;
+}
+
+function extractTextFromAssistantMessageParts(parts: unknown): string {
+  if (!Array.isArray(parts)) return "";
+  const texts: string[] = [];
+  for (const part of parts) {
+    if (!part || typeof part !== "object") continue;
+    const p = part as { type?: unknown; text?: unknown };
+    if (p.type !== "text" && p.type !== "input_text") continue;
+    if (typeof p.text !== "string") continue;
+    const value = p.text.trim();
+    if (!value) continue;
+    texts.push(value);
+  }
+  return texts.join("\n").trim();
+}
+
+/**
+ * 从 assistant 输出中提取 task 的最终结果文本。
+ *
+ * 关键点（中文）
+ * - 这里故意保持最简：只取最后 assistant 返回中的文本内容。
+ * - 不再额外解析 `chat_send` tool call，也不再区分“过程发送文本”与“最终结果文本”。
+ * - task 的过程内容保留在 `messages.jsonl / dialogue.md`；`output.md` 只记录最后 assistant 文本。
+ */
+export function pickAgentOutput(
+  assistantMessage: SessionRunResult["assistantMessage"],
+): ChatSendOutputPick {
+  return {
+    text: extractTextFromAssistantMessageParts(
+      (assistantMessage as { parts?: unknown } | null)?.parts,
+    ),
+    delivered: false,
+  };
+}
+
+/**
+ * 解析模拟用户 agent 的判定结果。
+ */
+export function parseUserSimulatorDecision(outputText: string): UserSimulatorDecision {
+  const raw = String(outputText ?? "").trim();
+  const obj = tryExtractJsonObject(raw);
+  if (obj) {
+    const satisfiedRaw = obj.satisfied;
+    const satisfied =
+      satisfiedRaw === true ||
+      (typeof satisfiedRaw === "string" && satisfiedRaw.trim().toLowerCase() === "true");
+    const reply = String(obj.reply ?? "").trim();
+    const reason = String(obj.reason ?? "").trim();
+    const scoreRaw = obj.score;
+    const score =
+      typeof scoreRaw === "number"
+        ? scoreRaw
+        : typeof scoreRaw === "string" && /^(\d+)(\.\d+)?$/.test(scoreRaw.trim())
+          ? Number(scoreRaw)
+          : undefined;
+    const normalizedScore =
+      typeof score === "number" && Number.isFinite(score) && score >= 0 && score <= 10
+        ? score
+        : undefined;
+    return {
+      satisfied,
+      reply,
+      reason,
+      ...(typeof normalizedScore === "number" ? { score: normalizedScore } : {}),
+      raw,
+    };
+  }
+
+  const lower = raw.toLowerCase();
+  const likelySatisfied =
+    (lower.includes("satisfied") || lower.includes("满意") || lower.includes("通过")) &&
+    !lower.includes("not satisfied") &&
+    !lower.includes("不满意");
+
+  return {
+    satisfied: likelySatisfied,
+    reply: raw,
+    reason: likelySatisfied ? "heuristic satisfied" : "heuristic not satisfied",
+    raw,
+  };
+}
+
+/**
+ * 构造执行 agent 的轮次输入。
+ */
+export function buildExecutorRoundQuery(params: {
+  taskBody: string;
+  round: number;
+  lastOutputText?: string;
+  lastFeedback?: string;
+}): string {
+  if (params.round <= 1) return params.taskBody;
+  return [
+    "# 任务目标（保持不变）",
+    "",
+    params.taskBody || "_(empty body)_",
+    "",
+    `# 这是第 ${params.round} 轮执行`,
+    "",
+    "请根据以下“模拟用户反馈”和“上一轮输出”进行修订，并给出新的完整结果。",
+    "",
+    "## 模拟用户反馈",
+    "",
+    params.lastFeedback ? params.lastFeedback : "_(no feedback)_",
+    "",
+    "## 上一轮输出",
+    "",
+    params.lastOutputText ? params.lastOutputText : "_(empty output)_",
+    "",
+  ].join("\n");
+}
+
+/**
+ * 构造模拟用户 agent 的判定输入。
+ */
+export function buildUserSimulatorQuery(params: {
+  taskTitle: string;
+  taskDescription: string;
+  taskBody: string;
+  round: number;
+  maxRounds: number;
+  executorOutputText: string;
+  ruleErrors: string[];
+}): string {
+  const ruleSection =
+    params.ruleErrors.length > 0
+      ? params.ruleErrors.map((x) => `- ${x}`).join("\n")
+      : "- (none)";
+  return [
+    "你是一个“模拟用户”Agent。你要根据任务目标审阅执行结果，并给出用户回复。",
+    "",
+    "请严格输出 JSON 对象（不要输出 markdown）：",
+    '{"satisfied": boolean, "reply": string, "reason": string, "score": number}',
+    "",
+    "规则：",
+    "1) 如果结果还不满足目标，satisfied 必须是 false，reply 要像用户一样明确提出修改要求。",
+    "2) 如果已经满足，satisfied=true，reply 给简短确认。",
+    "3) score 范围 0-10。",
+    "4) 如果系统规则校验有失败项（见下方），必须判定为不满意。",
+    "",
+    `任务标题: ${params.taskTitle}`,
+    `任务描述: ${params.taskDescription}`,
+    `当前轮次: ${params.round}/${params.maxRounds}`,
+    "",
+    "任务正文：",
+    params.taskBody || "_(empty body)_",
+    "",
+    "系统规则校验失败项：",
+    ruleSection,
+    "",
+    "执行 Agent 本轮输出：",
+    params.executorOutputText || "_(empty output)_",
+    "",
+  ].join("\n");
+}
+
+/**
+ * 执行一轮 agent.run。
+ */
+export async function runAgentRound(params: {
+  taskSessionRuntime: TaskSessionRuntimePort;
+  sessionId: string;
+  taskId: string;
+  query: string;
+  actorId: string;
+  actorName: string;
+}): Promise<{ outputText: string; delivered: boolean; rawResult: SessionRunResult }> {
+  try {
+    await appendTaskRoundUserMessage({
+      taskSessionRuntime: params.taskSessionRuntime,
+      sessionId: params.sessionId,
+      taskId: params.taskId,
+      query: params.query,
+      actorId: params.actorId,
+      actorName: params.actorName,
+    });
+  } catch {
+    // ignore
+  }
+
+  const result = await withSessionRunScope(
+    {
+      sessionId: params.sessionId,
+    },
+    () =>
+      params.taskSessionRuntime.getExecutor(params.sessionId).run({
+        query: params.query,
+      }),
+  );
+  const outputPick = pickAgentOutput(result.assistantMessage);
+
+  if (!result.success) {
+    const reason = outputPick.text || "agent run returned success=false";
+    throw new Error(reason);
+  }
+
+  if (!String(outputPick.text || "").trim()) {
+    throw new Error("agent produced no user-visible output");
+  }
+
+  return {
+    outputText: outputPick.text,
+    delivered: outputPick.delivered,
+    rawResult: result,
+  };
+}
+
+/**
+ * 执行 script 类型任务。
+ */
+export async function runScriptTask(params: {
+  context: AgentContext;
+  runDirAbs: string;
+  sessionId: string;
+  scriptBody: string;
+}): Promise<ScriptExecutionResult> {
+  const body = String(params.scriptBody || "");
+  if (!body.trim()) throw new Error("script task body cannot be empty");
+
+  const scriptAbs = path.join(params.runDirAbs, "task-script.sh");
+  await fs.writeFile(scriptAbs, body.endsWith("\n") ? body : `${body}\n`, "utf-8");
+
+  const execResult = await withSessionRunScope(
+    { sessionId: params.sessionId },
+    () => {
+      const childEnv: NodeJS.ProcessEnv = {
+        ...process.env,
+        DC_SESSION_ID: params.sessionId,
+      };
+      stripInvocationAuthEnv(childEnv);
+      return runSandboxCommand({
+        context: params.context,
+        shellId: `task-script:${params.sessionId}`,
+        shellDir: params.runDirAbs,
+        cmd: `sh "${scriptAbs.replace(/(["\\$`])/g, "\\$1")}"`,
+        cwd: params.runDirAbs,
+        shellPath: "/bin/sh",
+        login: false,
+        baseEnv: childEnv,
+      });
+    }
+  );
+
+  const stdout = String(execResult.stdout || "").trim();
+  const stderr = String(execResult.stderr || "").trim();
+  const combined = [stdout, stderr].filter(Boolean).join("\n");
+  return {
+    outputText: combined,
+  };
+}
+
+/**
+ * 校验任务结果是否满足“必须有结果”的规则。
+ */
+export async function validateTaskResult(params: {
+  outputText: string;
+}): Promise<TaskResultValidation> {
+  const errors: string[] = [];
+  const minOutputChars = 1;
+  const outputChars = String(params.outputText ?? "").trim().length;
+  if (outputChars < minOutputChars) {
+    errors.push(`output too short: got ${outputChars}, expected >= ${minOutputChars}`);
+  }
+
+  if (errors.length > 0) {
+    return {
+      resultStatus: "invalid",
+      errors,
+    };
+  }
+
+  return {
+    resultStatus: "valid",
+    errors: [],
+  };
+}

package/src/services/task/runtime/TaskRunnerSession.ts

@@ -0,0 +1,167 @@
+/**
+ * TaskRunnerSession：task runner 的 session 装配模块。
+ *
+ * 关键点（中文）
+ * - 负责构建 task 专用 LocalSessionCore / JsonlSessionHistoryComposer 运行时。
+ * - 负责把每轮 user/assistant 消息写入 run 目录对应的 messages.jsonl。
+ * - 这些能力与任务编排逻辑解耦后，Runner 主流程会更聚焦于状态流转。
+ * - 当前只有 api 执行模式。
+ */
+
+import path from "node:path";
+import type { AgentContext } from "@/types/agent/AgentContext.js";
+import type { SessionRunResult } from "@/types/session/SessionRun.js";
+import type { TaskSessionRuntimePort } from "@/types/task/TaskRunner.js";
+import { LocalSessionCore } from "@session/executors/local/LocalSessionCore.js";
+import { drainDeferredPersistedUserMessages } from "@session/SessionRunScope.js";
+import { JsonlSessionHistoryComposer } from "@session/composer/history/jsonl/JsonlSessionHistoryComposer.js";
+import { JsonlSessionCompactionComposer } from "@session/composer/compaction/jsonl/JsonlSessionCompactionComposer.js";
+import { LocalSessionExecutionComposer } from "@session/composer/execution/LocalSessionExecutionComposer.js";
+import { DefaultSessionSystemComposer } from "@session/composer/system/default/DefaultSessionSystemComposer.js";
+import { shellTools } from "@session/tools/shell/ShellToolDefinition.js";
+import type { SessionExecutor } from "@/types/session/SessionExecutor.js";
+
+/**
+ * 把 task round 的 user query 落盘到对应 run context。
+ */
+export async function appendTaskRoundUserMessage(params: {
+  taskSessionRuntime: TaskSessionRuntimePort;
+  sessionId: string;
+  taskId: string;
+  query: string;
+  actorId: string;
+  actorName: string;
+}): Promise<void> {
+  const text = String(params.query || "").trim();
+  if (!text) return;
+  const historyComposer = params.taskSessionRuntime.getHistoryComposer(params.sessionId);
+  await historyComposer.append(
+    historyComposer.userText({
+      text,
+      metadata: {
+        sessionId: params.sessionId,
+        extra: {
+          taskId: params.taskId,
+          actorId: params.actorId,
+          actorName: params.actorName,
+        },
+      },
+    }),
+  );
+}
+
+/**
+ * 构建 task 专用 Session 运行时（独立于普通 Session 实例缓存）。
+ *
+ * 关键点（中文）
+ * - 使用 LocalSessionCore 执行，模型来自 context.session.model（agent 级模型）。
+ */
+export function createTaskSessionRuntimePort(params: {
+  context: AgentContext;
+  runDirAbs: string;
+  runSessionId: string;
+  userSimulatorSessionId: string;
+}): TaskSessionRuntimePort {
+  const { context, runDirAbs, runSessionId, userSimulatorSessionId } = params;
+  const compactionComposer = new JsonlSessionCompactionComposer({
+    keepLastMessages: context.config.context?.messages?.keepLastMessages,
+    maxInputTokensApprox: context.config.context?.messages?.maxInputTokensApprox,
+    archiveOnCompact: context.config.context?.messages?.archiveOnCompact,
+    compactRatio: context.config.context?.messages?.compactRatio,
+  });
+  const systemComposer = new DefaultSessionSystemComposer({
+    projectRoot: context.rootPath,
+    getStaticSystemPrompts: () => context.systems,
+    getContext: () => context,
+    profile: "task",
+  });
+  const historyComposersBySessionId = new Map<string, JsonlSessionHistoryComposer>();
+  const runtimesBySessionId = new Map<string, SessionExecutor>();
+
+  const resolveTaskHistoryComposer = (sessionId: string): JsonlSessionHistoryComposer => {
+    const existing = historyComposersBySessionId.get(sessionId);
+    if (existing) return existing;
+
+    const key = String(sessionId || "").trim();
+    if (!key) {
+      throw new Error("TaskSessionRuntimePort requires a non-empty sessionId");
+    }
+    const runMessagesDirPath =
+      key === runSessionId
+        ? runDirAbs
+        : key === userSimulatorSessionId
+          ? path.join(runDirAbs, "user-simulator")
+          : undefined;
+
+    const created = new JsonlSessionHistoryComposer({
+      rootPath: context.rootPath,
+      sessionId: key,
+      ...(runMessagesDirPath
+        ? {
+            paths: {
+              sessionDirPath: runMessagesDirPath,
+              messagesDirPath: runMessagesDirPath,
+              messagesFilePath: path.join(runMessagesDirPath, "messages.jsonl"),
+              metaFilePath: path.join(runMessagesDirPath, "meta.json"),
+              archiveDirPath: path.join(runMessagesDirPath, "archive"),
+            },
+          }
+        : {}),
+    });
+    historyComposersBySessionId.set(key, created);
+    return created;
+  };
+
+  return {
+    getHistoryComposer(sessionId: string): JsonlSessionHistoryComposer {
+      return resolveTaskHistoryComposer(sessionId);
+    },
+    getExecutor(sessionId: string): SessionExecutor {
+      const key = String(sessionId || "").trim();
+      if (!key) {
+        throw new Error("TaskSessionRuntimePort.getExecutor requires a non-empty sessionId");
+      }
+      const existing = runtimesBySessionId.get(key);
+      if (existing) return existing;
+
+      const historyComposer = resolveTaskHistoryComposer(key);
+      if (!context.session.model) {
+        throw new Error("TaskSessionRuntimePort requires session.model");
+      }
+      const executionComposer = new LocalSessionExecutionComposer({
+        sessionId: key,
+        getTools: () => shellTools,
+      });
+      const created = new LocalSessionCore({
+        model: context.session.model,
+        logger: context.logger,
+        historyComposer,
+        compactionComposer,
+        executionComposer,
+        systemComposer,
+      });
+      runtimesBySessionId.set(key, created);
+      return created;
+    },
+  };
+}
+
+/**
+ * 把 task session 的 assistant 消息落盘到对应 run context history Composer。
+ */
+export async function appendTaskAssistantMessage(params: {
+  taskSessionRuntime: TaskSessionRuntimePort;
+  sessionId: string;
+  taskId: string;
+  rawResult: SessionRunResult;
+}): Promise<void> {
+  const { taskSessionRuntime, sessionId, rawResult } = params;
+  const historyComposer = taskSessionRuntime.getHistoryComposer(sessionId);
+  if (rawResult.assistantMessage) {
+    await historyComposer.append(rawResult.assistantMessage);
+  }
+  const deferredUserMessages = drainDeferredPersistedUserMessages(sessionId);
+  for (const deferred of deferredUserMessages) {
+    await historyComposer.append(deferred);
+  }
+}