@ai-setting/roy-agent-core 1.7.72 → 1.7.76

package/dist/shared/@ai-setting/roy-agent-core-2akfd64z.js

@@ -0,0 +1,374 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-7f7t9wwp.js";
+
+// src/env/tool/built-in/query-background-process-tool.ts
+import { z } from "zod";
+var QueryBackgroundProcessParameters = z.object({
+  bgProcessId: z.string().min(1, "bgProcessId must not be empty").describe("The background process ID returned by delegate_task " + "(format: process_<timestamp>_<random>).")
+});
+function backgroundTaskToOutput(task) {
+  return {
+    alive: task.status === "pending" || task.status === "running",
+    status: task.status,
+    createdAt: task.createdAt,
+    lastUpdatedAt: task.lastUpdatedAt ?? task.completedAt ?? task.startedAt ?? task.createdAt,
+    description: task.description,
+    ...task.result !== undefined ? { result: task.result } : {},
+    ...task.error !== undefined ? { error: task.error } : {}
+  };
+}
+function notFoundOutput(bgProcessId) {
+  const now = Date.now();
+  return {
+    alive: false,
+    status: "not_found",
+    createdAt: now,
+    lastUpdatedAt: now,
+    description: `No background process found with id '${bgProcessId}'.`
+  };
+}
+var queryBackgroundProcessTool = {
+  name: "query_background_process",
+  description: `Query the status of a background process previously launched via delegate_task.
+
+` + `Use this tool when:
+` + `  - You delegated a long-running task but have NOT received any notification after a reasonable wait (5+ minutes), and want to confirm whether the process is still alive.
+` + `  - The user asks about the progress of a delegated task and you need a current snapshot.
+` + `  - You suspect a delegated task got stuck (no progress messages, no completion notification).
+
+` + `DO NOT poll this tool on every turn — it is meant for diagnostic checks at a reasonable cadence (e.g. every few minutes, or when you genuinely suspect the task is stuck).
+
+` + `Returns a JSON object with:
+` + `  - alive: boolean — true if status is 'pending' or 'running'
+` + `  - status: 'pending' | 'running' | 'completed' | 'failed' | 'stopped' | 'timeout' | 'not_found'
+` + `  - createdAt, lastUpdatedAt: timestamps (ms)
+` + `  - description: the task description you passed to delegate_task
+` + `  - result: present when status is 'completed'
+` + `  - error: present when status is 'failed'
+
+` + "Only the default receptionist agent has this tool. Sub-agents (roy, strict-task-agent, etc.) cannot see it because they do not need to query background tasks they themselves launched.",
+  parameters: QueryBackgroundProcessParameters,
+  permission: {
+    level: "safe",
+    requireConfirmation: false
+  },
+  metadata: {
+    category: "task",
+    tags: ["background", "delegate", "query", "status", "diagnostic"],
+    version: "1.0.0",
+    allowedAgentTypes: ["default"]
+  },
+  execute: async (args, ctx) => createQueryBackgroundProcessTool(null).execute(args, ctx)
+};
+function createQueryBackgroundProcessTool(manager = null) {
+  return {
+    name: "query_background_process",
+    description: `Query the status of a background process previously launched via delegate_task.
+
+` + `Use this tool when:
+` + `  - You delegated a long-running task but have NOT received any notification after a reasonable wait (5+ minutes), and want to confirm whether the process is still alive.
+` + `  - The user asks about the progress of a delegated task and you need a current snapshot.
+` + `  - You suspect a delegated task got stuck (no progress messages, no completion notification).
+
+` + `DO NOT poll this tool on every turn — it is meant for diagnostic checks at a reasonable cadence (e.g. every few minutes, or when you genuinely suspect the task is stuck).
+
+` + `Returns a JSON object with:
+` + `  - alive: boolean — true if status is 'pending' or 'running'
+` + `  - status: 'pending' | 'running' | 'completed' | 'failed' | 'stopped' | 'timeout' | 'not_found'
+` + `  - createdAt, lastUpdatedAt: timestamps (ms)
+` + `  - description: the task description you passed to delegate_task
+` + `  - result: present when status is 'completed'
+` + `  - error: present when status is 'failed'
+
+` + "Only the default receptionist agent has this tool. Sub-agents (roy, strict-task-agent, etc.) cannot see it because they do not need to query background tasks they themselves launched.",
+    parameters: QueryBackgroundProcessParameters,
+    permission: {
+      level: "safe",
+      requireConfirmation: false
+    },
+    metadata: {
+      category: "task",
+      tags: ["background", "delegate", "query", "status", "diagnostic"],
+      version: "1.0.0",
+      allowedAgentTypes: ["default"]
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const params = QueryBackgroundProcessParameters.parse(args);
+      const { bgProcessId } = params;
+      if (!manager) {
+        return {
+          success: false,
+          output: "",
+          error: "query_background_process is not initialized: no BackgroundTaskManager " + "has been bound. TaskComponent should call " + "createQueryBackgroundProcessTool(manager) and register the tool " + "during startup.",
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      let task;
+      try {
+        task = manager.getTask(bgProcessId);
+      } catch (err) {
+        return {
+          success: false,
+          output: "",
+          error: `failed to query background task: ${err.message}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      if (task) {
+        const currentSessionId = ctx.session_id;
+        if (!currentSessionId || task.parentSessionId !== currentSessionId) {
+          return {
+            success: true,
+            output: JSON.stringify(notFoundOutput(bgProcessId), null, 2),
+            metadata: {
+              execution_time_ms: Date.now() - startTime,
+              bgProcessId,
+              status: "not_found",
+              alive: false
+            }
+          };
+        }
+      }
+      const output = task ? backgroundTaskToOutput(task) : notFoundOutput(bgProcessId);
+      if (output.alive) {
+        try {
+          const activity = await manager.getSubSessionActivity?.(bgProcessId);
+          if (activity) {
+            output.lastUpdatedAt = Math.max(output.lastUpdatedAt, activity.updatedAt);
+            output.messageCount = activity.messageCount;
+            output.subSessionUpdatedAt = activity.updatedAt;
+          }
+        } catch {}
+      }
+      return {
+        success: true,
+        output: JSON.stringify(output, null, 2),
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          bgProcessId,
+          status: output.status,
+          alive: output.alive
+        }
+      };
+    }
+  };
+}
+
+// src/env/tool/built-in/compact-session-tool.ts
+init_logger();
+import { z as z2 } from "zod";
+var logger = createLogger("compact-session-tool");
+var CompactSessionParameters = z2.object({
+  session_id: z2.string().min(1, "session_id must not be empty").describe("The sub-session ID to compact (format: session_xxx or oc_xxx). " + "Must be a sub-session previously created via delegate_task " + "(the bgProcess notification reports its subSessionId).")
+});
+function compactSessionNotFoundOutput(sessionId) {
+  return {
+    status: "not_found",
+    sessionId
+  };
+}
+function findTaskBySubSessionId(manager, sessionId) {
+  const tasks = manager.listTasks() ?? [];
+  const bySubSession = tasks.find((t) => t.subSessionId === sessionId);
+  if (bySubSession)
+    return bySubSession;
+  return manager.getTask(sessionId);
+}
+function isOwnSubSession(task, currentSessionId) {
+  if (!task || !currentSessionId)
+    return false;
+  return task.parentSessionId === currentSessionId;
+}
+function isTaskActive(task) {
+  return task?.status === "running" || task?.status === "pending";
+}
+function createCompactSessionTool(backgroundTaskManager = null, sessionComponent = null) {
+  return {
+    name: "compact_session",
+    description: "Compact (compress) a sub-agent session by summarizing its history " + "into a checkpoint and archiving the old messages, so the session " + "can be REUSED with delegate_task(sub_session_id=...) without " + `exceeding the context threshold.
+
+` + `Use this tool when:
+` + "  - A delegated sub-agent returned 'Context threshold exceeded' " + "(e.g. 125575/120000 tokens) and you want to continue the SAME " + `sub-session instead of losing all its progress.
+` + "  - A sub-session is very long and the next resume would likely " + `hit the context limit again.
+
+` + `Behavior:
+` + "  1. Generates a checkpoint (natural-language summary of the " + `conversation so far)
+` + "  2. Archives the old messages (they remain queryable but leave " + `the active context)
+` + `  3. Returns a JSON summary of the compaction
+
+` + `After compaction succeeds, resume the sub-session with:
+` + '  delegate_task(subagent_type="...", sub_session_id="<same id>", ' + `prompt="continue from the checkpoint")
+
+` + `Guards:
+` + `  - You CANNOT compact your own current session (self-destruction).
+` + `  - You can only compact sub-sessions YOU delegated (ownership check).
+` + "  - A session whose background task is still running/pending cannot " + `be compacted (stop_task it first to avoid corrupting live state).
+
+` + "Only the default receptionist agent has this tool.",
+    parameters: CompactSessionParameters,
+    permission: {
+      level: "safe",
+      requireConfirmation: false
+    },
+    metadata: {
+      category: "task",
+      tags: ["compact", "session", "delegate", "checkpoint", "context"],
+      version: "1.0.0",
+      allowedAgentTypes: ["default"]
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const params = CompactSessionParameters.parse(args);
+      const sessionId = params.session_id;
+      if (!backgroundTaskManager || !sessionComponent) {
+        return {
+          success: false,
+          output: "",
+          error: "compact_session is not initialized: no BackgroundTaskManager " + "or SessionComponent has been bound. TaskComponent should call " + "createCompactSessionTool(manager, sessionComponent) and " + "register the tool during startup.",
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      const currentSessionId = ctx.session_id;
+      if (currentSessionId && sessionId === currentSessionId) {
+        return {
+          success: false,
+          output: "",
+          error: `Refusing to compact session '${sessionId}': it is your OWN ` + `current session. Compacting it would destroy your own active ` + `context. Only sub-sessions you delegated can be compacted.`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      if (!currentSessionId) {
+        return {
+          success: false,
+          output: "",
+          error: "compact_session requires a current session context " + "(ctx.session_id) to verify ownership, but none was provided.",
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      const task = findTaskBySubSessionId(backgroundTaskManager, sessionId);
+      if (!task || !isOwnSubSession(task, currentSessionId)) {
+        logger.warn("[compact_session] not_found (unknown or foreign sub-session)", { sessionId, currentSessionId });
+        return {
+          success: true,
+          output: JSON.stringify(compactSessionNotFoundOutput(sessionId), null, 2),
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            sessionId,
+            status: "not_found"
+          }
+        };
+      }
+      if (isTaskActive(task)) {
+        return {
+          success: false,
+          output: "",
+          error: `Cannot compact session '${sessionId}': its background task ` + `'${task.id}' is still ${task.status}. The sub-agent writes ` + `to this session every ReAct iteration; archiving messages ` + `now would corrupt live state. Run ` + `stop_task(task_id="${task.id}") first, then compact the ` + `session.`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            sessionId,
+            bgProcessId: task.id,
+            taskStatus: task.status
+          }
+        };
+      }
+      let preview;
+      try {
+        preview = await sessionComponent.previewCompact(sessionId);
+      } catch (err) {
+        return {
+          success: false,
+          output: "",
+          error: `failed to preview compaction for session '${sessionId}': ` + `${err.message}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      if (!preview || preview.messageCountToCompact < 3) {
+        return {
+          success: false,
+          output: "",
+          error: `Cannot compact session '${sessionId}': minimum 3 compactable ` + `messages required (found ` + `${preview?.messageCountToCompact ?? 0}).`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            sessionId,
+            messageCountToCompact: preview?.messageCountToCompact ?? 0
+          }
+        };
+      }
+      let scenarioHint = "";
+      try {
+        scenarioHint = await sessionComponent.generateCompactHint(sessionId);
+      } catch (err) {
+        logger.warn("[compact_session] hint generation failed, continuing with empty hint", { sessionId, error: err.message });
+        scenarioHint = "";
+      }
+      let compactResult;
+      try {
+        compactResult = await sessionComponent.compact(sessionId, {
+          scenarioHint
+        });
+      } catch (err) {
+        const message = err.message;
+        logger.error(`[compact_session] compact failed: ${message}`, {
+          sessionId
+        });
+        return {
+          success: false,
+          output: "",
+          error: `compaction failed for session '${sessionId}': ${message}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            sessionId
+          }
+        };
+      }
+      try {
+        const env = backgroundTaskManager.env;
+        env?.pushEnvEvent?.({
+          type: "context.compacted",
+          metadata: { sessionId },
+          payload: {
+            checkpointId: compactResult.checkpoint.id,
+            messagesCompacted: compactResult.deletedMessageCount,
+            scenarioHintUsed: scenarioHint.length > 0,
+            source: "compact_session_tool"
+          }
+        });
+      } catch (err) {
+        logger.warn("[compact_session] failed to push context.compacted event", { sessionId, error: err.message });
+      }
+      const output = {
+        status: "compacted",
+        sessionId,
+        checkpointId: compactResult.checkpoint.id,
+        checkpointTitle: compactResult.checkpoint.title,
+        contentLength: compactResult.checkpoint.content?.length ?? 0,
+        originalMessages: preview.messageCountToCompact,
+        deletedMessages: compactResult.deletedMessageCount,
+        remainingMessages: compactResult.remainingMessageCount,
+        hintUsed: scenarioHint.length > 0
+      };
+      logger.info("[compact_session] session compacted", {
+        sessionId,
+        checkpointId: output.checkpointId,
+        deletedMessages: output.deletedMessages,
+        remainingMessages: output.remainingMessages
+      });
+      return {
+        success: true,
+        output: JSON.stringify(output, null, 2),
+        metadata: {
+          execution_time_ms: Date.now() - startTime,
+          sessionId,
+          status: "compacted",
+          checkpointId: output.checkpointId
+        }
+      };
+    }
+  };
+}
+var compactSessionTool = createCompactSessionTool(null, null);
+
+export { queryBackgroundProcessTool, createQueryBackgroundProcessTool, createCompactSessionTool, compactSessionTool };

package/dist/shared/@ai-setting/{roy-agent-core-skyc30qx.js → roy-agent-core-3fh1f7s7.js}

@@ -1,9 +1,9 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-attpry6g.js";
+} from "./roy-agent-core-dqxec05w.js";
 import"./roy-agent-core-1db4vpc6.js";
-import"./roy-agent-core-e25xkv53.js";
+import"./roy-agent-core-mkc3zshb.js";
 import"./roy-agent-core-cpcd24n2.js";
 import"./roy-agent-core-qqaak24r.js";
 import"./roy-agent-core-7cbpmk4q.js";

package/dist/shared/@ai-setting/roy-agent-core-4rtg69cn.js

@@ -0,0 +1,26 @@
+// src/env/task/tools/completion-copy.ts
+var TASK_COMPLETE_ITEM_BY_ITEM = "按子项逐条验收";
+var TASK_COMPLETION_HINT_ANCHOR = "TASK_COMPLETION_HINT";
+var TASK_COMPLETE_VERIFY_DUTY = "核实义务";
+var TASK_COMPLETE_ACCEPTANCE = {
+  itemByItem: TASK_COMPLETE_ITEM_BY_ITEM,
+  hintAnchor: TASK_COMPLETION_HINT_ANCHOR,
+  verifyDuty: TASK_COMPLETE_VERIFY_DUTY
+};
+var TASK_COMPLETED_STATUS_WORD = "已完成";
+var TASK_CANCELLED_STATUS_WORD = "已取消";
+var TASK_DELIVERABLE_RECORDED = "交付物已记录";
+var TASK_ARCHIVED_STATUS_WORD = "已归档";
+var TASK_REOPENED_STATUS_WORD = "已重新打开";
+var TASK_TO_VALIDATE_STATUS_WORD = "待验证";
+var TASK_TERMINAL_STATUS_WORDS = [
+  TASK_COMPLETED_STATUS_WORD,
+  TASK_CANCELLED_STATUS_WORD,
+  TASK_ARCHIVED_STATUS_WORD
+];
+var TERMINAL_NON_ACCEPTABLE_STATUSES = [
+  "cancelled",
+  "archived"
+];
+
+export { TASK_COMPLETE_ITEM_BY_ITEM, TASK_COMPLETION_HINT_ANCHOR, TASK_COMPLETE_VERIFY_DUTY, TASK_COMPLETE_ACCEPTANCE, TASK_COMPLETED_STATUS_WORD, TASK_CANCELLED_STATUS_WORD, TASK_DELIVERABLE_RECORDED, TASK_ARCHIVED_STATUS_WORD, TASK_REOPENED_STATUS_WORD, TASK_TO_VALIDATE_STATUS_WORD, TASK_TERMINAL_STATUS_WORDS, TERMINAL_NON_ACCEPTABLE_STATUSES };

package/dist/shared/@ai-setting/{roy-agent-core-add1zqsh.js → roy-agent-core-6cy43nss.js}

@@ -401,6 +401,27 @@ function __resetFailureReplyDedupForTest() {
   repliedTriggers.clear();
 }
 var DEFAULT_REPLY_TIMEOUT_MS = 5000;
+async function deliverAskUserMessage(options) {
+  const { chatId, messageId, profile, content } = options;
+  if (!chatId && !messageId) {
+    return { sent: false, error: "no-target" };
+  }
+  try {
+    await spawnLarkReply({
+      chatId,
+      messageId,
+      content,
+      profile,
+      timeoutMs: options.timeoutMs ?? DEFAULT_REPLY_TIMEOUT_MS
+    });
+    return { sent: true };
+  } catch (err) {
+    return {
+      sent: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
 function spawnLarkReply(options) {
   return new Promise((resolve, reject) => {
     const { chatId, messageId, content, profile } = options;
@@ -521,4 +542,4 @@ async function notifyReactFailure(options) {
   }
 }
 
-export { extractRetryAfterSeconds, humanizeRetryAfter, getFailureRuleIds, classifyReactFailure, buildFailureReplyMarkdown, formatCliFailureLine, __resetFailureReplyDedupForTest, notifyReactFailure };
+export { extractRetryAfterSeconds, humanizeRetryAfter, getFailureRuleIds, classifyReactFailure, buildFailureReplyMarkdown, formatCliFailureLine, __resetFailureReplyDedupForTest, deliverAskUserMessage, notifyReactFailure };

package/dist/shared/@ai-setting/{roy-agent-core-vah6g5yx.js → roy-agent-core-6rh8k6ba.js}

@@ -7,7 +7,7 @@ import {
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-attpry6g.js";
+} from "./roy-agent-core-dqxec05w.js";
 import {
   PythonCallNode,
   SkillNode,
@@ -37,23 +37,23 @@ import {
 import {
   TemplateResolver,
   init_template_resolver
-} from "./roy-agent-core-sjr1kmfz.js";
+} from "./roy-agent-core-acj8ag08.js";
 import {
   DAGManager,
   init_dag_manager
-} from "./roy-agent-core-mds8tqd0.js";
+} from "./roy-agent-core-cgtq6427.js";
 import {
   WorkflowError,
   createWorkflowEvent,
   init_event,
   init_types,
   init_workflow_error
-} from "./roy-agent-core-jrj30vq3.js";
+} from "./roy-agent-core-er070zjq.js";
 import {
   AskUserError,
   createNodeInterruptEvent,
   init_workflow_hil
-} from "./roy-agent-core-e25xkv53.js";
+} from "./roy-agent-core-mkc3zshb.js";
 import {
   TracedAs,
   init_decorator

package/dist/shared/@ai-setting/{roy-agent-core-kpg25s2q.js → roy-agent-core-8ez6mccb.js}

@@ -2,8 +2,9 @@ import {
   understandImageTool
 } from "./roy-agent-core-xwm8zavb.js";
 import {
+  compactSessionTool,
   queryBackgroundProcessTool
-} from "./roy-agent-core-58804s3j.js";
+} from "./roy-agent-core-2akfd64z.js";
 import {
   getCurrentProcessRegistry,
   killProcessTree
@@ -939,7 +940,8 @@ function getAllBuiltInTools() {
     editFileTool,
     grepTool,
     understandImageTool,
-    queryBackgroundProcessTool
+    queryBackgroundProcessTool,
+    compactSessionTool
   ];
 }
 function getBuiltInTool(name) {