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

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

@@ -0,0 +1,247 @@
+import {
+  init_decorator,
+  wrapFunction
+} from "./roy-agent-core-qq96p0tj.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-7f7t9wwp.js";
+
+// src/env/task/plugins/task-op-watermark-plugin.ts
+init_logger();
+
+// src/env/task/plugins/fake-user-message-helper.ts
+init_decorator();
+var KIND_PRIORITY = {
+  delegate: 10,
+  "task-ops": 20,
+  "max-iter": 30
+};
+var KIND_FIELD = "__fakeUserMessageKind";
+function ensureMetadata(toolResult) {
+  if (!toolResult)
+    return;
+  if (!toolResult.result)
+    toolResult.result = {};
+  if (!toolResult.result.metadata)
+    toolResult.result.metadata = {};
+  return toolResult.result.metadata;
+}
+function stringContent(msg) {
+  const c = msg?.content;
+  return typeof c === "string" ? c : JSON.stringify(c);
+}
+function enqueueToAddFakeUserMessageImpl(toolResult, newMsg, newKind) {
+  const meta = ensureMetadata(toolResult);
+  if (!meta)
+    return { willMerge: false, finalKind: newKind };
+  const existing = meta.toAddFakeUserMessage;
+  const existingKind = meta[KIND_FIELD];
+  if (!existing) {
+    meta.toAddFakeUserMessage = newMsg;
+    meta[KIND_FIELD] = newKind;
+    return { willMerge: false, finalKind: newKind };
+  }
+  let merged;
+  if (KIND_PRIORITY[newKind] >= KIND_PRIORITY[existingKind ?? newKind]) {
+    merged = {
+      role: "user",
+      content: `${stringContent(existing)}
+
+${stringContent(newMsg)}`
+    };
+  } else {
+    merged = {
+      role: "user",
+      content: `${stringContent(newMsg)}
+
+${stringContent(existing)}`
+    };
+  }
+  meta.toAddFakeUserMessage = merged;
+  const finalKind = KIND_PRIORITY[newKind] >= KIND_PRIORITY[existingKind ?? newKind] ? newKind : existingKind ?? newKind;
+  meta[KIND_FIELD] = finalKind;
+  return { willMerge: true, finalKind };
+}
+var enqueueToAddFakeUserMessage = wrapFunction(enqueueToAddFakeUserMessageImpl, "plugin.fake-user-message.enqueue", {
+  recordParams: false,
+  recordResult: false,
+  log: true,
+  resultFilter: (result) => ({
+    "fake-user-message.will_merge": result.willMerge,
+    "fake-user-message.final_kind": result.finalKind
+  })
+});
+
+// src/env/task/plugins/task-op-watermark-plugin.ts
+var logger = createLogger("TaskOpWatermarkPlugin");
+var TASK_OP_WATERMARK_MAX_REMINDERS = 5;
+var TASK_OP_WATERMARK_MESSAGE_LIMIT = 1500;
+var TASK_OP_WATERMARK_AUDIT_INTERVAL = 15;
+var MAX_DETAIL_ITEMS = 3;
+var MAX_DESC_LENGTH = 200;
+var UNKNOWN_SESSION = "unknown";
+var TRUNCATION_SUFFIX = "…（已截断）";
+function truncate(s, max) {
+  if (s.length <= max)
+    return s;
+  return `${s.slice(0, max)}…（已截断）`;
+}
+function buildReminderMessage(taskId, taskTitle, ops) {
+  const count = ops.length;
+  const lines = [];
+  lines.push(`[task-ops] Task #${taskId}${taskTitle ? `「${taskTitle}」` : ""} 有 ${count} 条由**其他 agent** 新增的操作记录，请读取并按需调整你的行为。`);
+  lines.push("");
+  lines.push("最新记录：");
+  const details = ops.slice(0, MAX_DETAIL_ITEMS);
+  for (const op of details) {
+    const desc = op.milestoneDescription ? truncate(op.milestoneDescription.split(`
+`)[0], MAX_DESC_LENGTH) : "";
+    lines.push(`- [${op.milestoneType}] ${op.milestoneTitle}${desc ? `
+  ${desc}` : ""}`);
+  }
+  if (count > MAX_DETAIL_ITEMS) {
+    lines.push(`（其余 ${count - MAX_DETAIL_ITEMS} 条较旧记录省略，可用 task_operation_list 查看全部）`);
+  }
+  lines.push("");
+  lines.push(`请调用 task_operation_list(task_id=${taskId}) 读取全部新记录，判断是否需要修改你的计划、产出或下一步动作。`);
+  lines.push("若这些记录与你的当前工作无关，忽略即可，无需回复。");
+  return lines.join(`
+`);
+}
+
+class TaskOpWatermarkPlugin {
+  name = "TaskOpWatermarkPlugin";
+  version = "1.0.0";
+  description = "Task #5081 — agent:after.tool 水位比对：同一 task 出现他人（sessionId 过滤 + unknown 过滤）新增的 operation 时，经共享 meta-protocol 注入 user role 提醒（N 聚 1 / 限流 5 / 长度 1500 / 15 次兜底对账 / fresh 旁路绕 operationsCache）。";
+  priority = 40;
+  watermarks = new Map;
+  resolveTaskComponent;
+  constructor(config) {
+    this.resolveTaskComponent = config?.resolveTaskComponent;
+  }
+  async execute(ctx) {
+    try {
+      await this.check(ctx);
+    } catch (err) {
+      logger.warn(`[TaskOpWatermark] check failed (fail-open): ${err?.message}`);
+    }
+    return { continue: true };
+  }
+  async check(ctx) {
+    const sessionId = ctx.context?.sessionId;
+    if (!sessionId)
+      return;
+    const taskComponent = this.resolveTaskComponent?.();
+    if (!taskComponent)
+      return;
+    const taskIds = await this.resolveTaskIds(taskComponent, sessionId);
+    if (taskIds.length === 0)
+      return;
+    const taskKey = taskIds.join(",");
+    let wm = this.watermarks.get(sessionId);
+    if (!wm || wm.taskIds.join(",") !== taskKey) {
+      wm = {
+        lastSeenOpId: 0,
+        lastNotifiedOpId: 0,
+        taskIds,
+        reminderCount: 0,
+        toolsSinceAudit: 0
+      };
+      this.watermarks.set(sessionId, wm);
+    }
+    wm.toolsSinceAudit++;
+    const isAuditTurn = wm.toolsSinceAudit >= TASK_OP_WATERMARK_AUDIT_INTERVAL;
+    if (isAuditTurn)
+      wm.toolsSinceAudit = 0;
+    const lowerBound = isAuditTurn || wm.lastSeenOpId === 0 ? wm.lastNotifiedOpId : wm.lastSeenOpId;
+    let newOps = [];
+    let maxIdSeen = wm.lastSeenOpId;
+    for (const taskId of taskIds) {
+      const ops = await this.listOps(taskComponent, taskId);
+      const othersNew = ops.filter((op) => op.id > lowerBound && !this.isSelf(op, sessionId));
+      for (const op of othersNew) {
+        newOps.push(op);
+        if (op.id > maxIdSeen)
+          maxIdSeen = op.id;
+      }
+      const selfMax = ops.filter((op) => this.isSelf(op, sessionId)).reduce((m, op) => Math.max(m, op.id), 0);
+      maxIdSeen = Math.max(maxIdSeen, selfMax);
+    }
+    const seen = new Set;
+    newOps = newOps.filter((op) => seen.has(op.id) ? false : (seen.add(op.id), true)).sort((a, b) => b.id - a.id);
+    wm.lastSeenOpId = Math.max(wm.lastSeenOpId, maxIdSeen);
+    if (newOps.length === 0)
+      return;
+    if (wm.reminderCount >= TASK_OP_WATERMARK_MAX_REMINDERS) {
+      logger.info(`[TaskOpWatermark] session=${sessionId.slice(0, 12)}... reminder limit reached (${wm.reminderCount}) — watermark advanced silently`);
+      return;
+    }
+    if (!ctx.toolResult)
+      return;
+    const byTask = new Map;
+    for (const op of newOps) {
+      const arr = byTask.get(op.taskId) ?? [];
+      arr.push(op);
+      byTask.set(op.taskId, arr);
+    }
+    const sections = [];
+    for (const [taskId, ops] of byTask) {
+      const title = (await safeGetTask(taskComponent, taskId))?.title;
+      sections.push(buildReminderMessage(taskId, title, ops));
+    }
+    const content = sections.join(`
+
+`);
+    const finalContent = content.length > TASK_OP_WATERMARK_MESSAGE_LIMIT ? `${content.slice(0, TASK_OP_WATERMARK_MESSAGE_LIMIT - TRUNCATION_SUFFIX.length)}${TRUNCATION_SUFFIX}` : content;
+    enqueueToAddFakeUserMessage(ctx.toolResult, { role: "user", content: finalContent }, "task-ops");
+    wm.reminderCount++;
+    const maxNotified = newOps.reduce((m, op) => Math.max(m, op.id), 0);
+    wm.lastNotifiedOpId = Math.max(wm.lastNotifiedOpId, maxNotified);
+    logger.info(`[TaskOpWatermark] reminder injected: session=${sessionId.slice(0, 12)}..., tasks=${[...byTask.keys()].join(",")}, newOps=${newOps.length}, reminderCount=${wm.reminderCount}`);
+  }
+  isSelf(op, sessionId) {
+    return op.sessionId === sessionId || op.sessionId === UNKNOWN_SESSION;
+  }
+  async resolveTaskIds(tc, sessionId) {
+    if (typeof tc.getTaskIdsBySessionId === "function") {
+      const ids = await tc.getTaskIdsBySessionId(sessionId);
+      return Array.isArray(ids) ? ids : [];
+    }
+    if (typeof tc.getTaskIdBySessionId === "function") {
+      const id = await tc.getTaskIdBySessionId(sessionId);
+      return typeof id === "number" ? [id] : [];
+    }
+    return [];
+  }
+  async listOps(tc, taskId) {
+    if (typeof tc.listOperationsFresh === "function") {
+      return await tc.listOperationsFresh({ taskId, limit: 50 });
+    }
+    if (typeof tc.invalidateOperationsCache === "function") {
+      tc.invalidateOperationsCache(taskId);
+    }
+    return await tc.listOperations({ taskId, limit: 50 });
+  }
+}
+async function safeGetTask(tc, taskId) {
+  try {
+    return await tc.getTask(taskId);
+  } catch {
+    return;
+  }
+}
+function createTaskOpWatermarkPlugin(config) {
+  const inst = new TaskOpWatermarkPlugin(config);
+  return {
+    name: inst.name,
+    version: inst.version,
+    description: inst.description,
+    hooks: [{ point: "agent:after.tool", priority: inst.priority }],
+    execute: async (ctx) => {
+      return inst.execute(ctx);
+    }
+  };
+}
+
+export { enqueueToAddFakeUserMessage, TASK_OP_WATERMARK_MAX_REMINDERS, TASK_OP_WATERMARK_MESSAGE_LIMIT, TASK_OP_WATERMARK_AUDIT_INTERVAL, TaskOpWatermarkPlugin, createTaskOpWatermarkPlugin };