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

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

@@ -0,0 +1,56 @@
+// src/env/tool/validator.ts
+import { ZodError } from "zod";
+var REASON_REQUIRED_CONFIG_KEY = "tool.reason.required";
+var moduleLevelReasonRequired = true;
+var configComponentRef = null;
+function setToolReasonConfigComponent(component) {
+  configComponentRef = component;
+}
+function isToolReasonRequired() {
+  if (configComponentRef) {
+    const v = configComponentRef.get(REASON_REQUIRED_CONFIG_KEY);
+    if (typeof v === "boolean")
+      return v;
+    if (typeof v === "string")
+      return v !== "false";
+  }
+  return moduleLevelReasonRequired;
+}
+
+class ToolValidator {
+  async validate(tool, args) {
+    if (isToolReasonRequired()) {
+      const reason = args?.["reason"];
+      if (typeof reason !== "string" || reason.trim() === "") {
+        return {
+          success: false,
+          error: `Missing or empty required parameter 'reason' for tool '${tool.name}': ` + `provide a one-sentence explanation of why you are calling this tool.`
+        };
+      }
+    }
+    try {
+      const parsed = await tool.parameters.parseAsync(args);
+      return {
+        success: true,
+        data: parsed
+      };
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const errorMessage = tool.formatValidationError ? tool.formatValidationError(error) : this.formatError(error);
+        return {
+          success: false,
+          error: `Invalid arguments for tool '${tool.name}': ${errorMessage}`
+        };
+      }
+      return {
+        success: false,
+        error: `Validation error: ${error}`
+      };
+    }
+  }
+  formatError(error) {
+    return error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+  }
+}
+
+export { setToolReasonConfigComponent, isToolReasonRequired, ToolValidator };

package/dist/shared/@ai-setting/{roy-agent-core-0snm5hc5.js → roy-agent-core-y6shd91r.js}

@@ -1,6 +1,6 @@
 import {
   safeParseToolArgs
-} from "./roy-agent-core-fghc2m8z.js";
+} from "./roy-agent-core-aa8kv18f.js";
 
 // src/env/session/session-message-converter.ts
 import { randomUUID } from "crypto";

package/dist/shared/@ai-setting/{roy-agent-core-9vxh6f8h.js → roy-agent-core-y7fqtzk2.js}

@@ -439,7 +439,7 @@ subSessionId: sub-session-xyz
 | session 规模 | 建议处置 |
 |---|---|
 | **小**（超限比例 < 30%，消息数不多） | 直接 \`compact_session\` → 压缩成功后用 \`sub_session_id\` 续跑 |
-| **大**（超限比例很高 / 消息数很多） | \`compact_session\` **可能要跑很久甚至撞 120s 工具超时** → **不要在同一个 session 上死磕**，直接**开新 session** + 明确列出「已完成项 / 断点 / 小目标」 |
+| **大**（超限比例很高 / 消息数很多） | \`compact_session\` **可能要跑很久甚至撞 120s 工具超时** → **不要在同一个 session 上死磕**，走下面的**兜底路径**（压缩复查 → 仍无效才开新 session）+ 明确列出「已完成项 / 断点 / 小目标」 |
 
 **为什么必须先评估**（实测数据）：
 
@@ -474,7 +474,7 @@ const r = await compact_session({ session_id: "sub-session-xyz" });
 2. **再检查一次**该 session 的**消息数 / checkpoint** —— \`compact_session\` 成功会返回 \`checkpointId\`，也可以用 session 相关工具确认消息是否已被 archived
 3. 再决定走哪条路：
    - **压缩其实成功了** → 用 \`sub_session_id\` 续跑（上下文已经变小，安全）
-   - **压缩确实没生效** → 才走下面的「开新 session」路径
+   - **压缩确实没生效** → 才走下面的兜底路径（换新 session）
 
 **第 3 步：带同一个 \`sub_session_id\` 续跑**
 
@@ -502,9 +502,9 @@ delegate_task({
 
 \`\`\`typescript
 delegate_task({
-  description: "接续工作（上下文已超限，改用新 session）",
+  description: "接续工作（上下文已超限，压缩复查后仍不可救，换新 session）",
   prompt: "【已完成】... \\n【断点】... \\n【小目标】... \\n【相关文件路径】... \\n【已知结论】...",
-  // 不传 sub_session_id —— 开新 session
+  sub_session_id: "sub-session-xyz",  // ⚠️ 兜底路径：仅在 compact_session 也无效时才省略
 });
 \`\`\`
 
@@ -512,9 +512,9 @@ delegate_task({
 
 #### ❌ 反模式警示
 
-- ❌ **不要从头重新委托**（不传 \`sub_session_id\` 直接 \`delegate_task\`）—— 丢掉全部上下文，前面的调研和代码全白做，还可能重复踩已解决过的坑。
-- ❌ **不要在压缩失败时反复用同一个 session 续跑** —— 同样的超限会再发生一次，徒增 token 消耗。压缩失败就走"开新 session + 明确列出已完成项/断点/小目标"的兜底路径。
-- ❌ **不要在 session 规模很大时死磕 \`compact_session\`** —— 先按第 0 步评估，message 数很多就直接开新 session。
+- ❌ **不要从头重新委托** —— 不传 \`sub_session_id\` 直接 \`delegate_task\` 是**最后手段**，只在旧 session 上下文已确认不可救（compact_session 后仍超限 / 迭代上限且无可复用断点）时才允许。其余情况一律带 \`sub_session_id\` 续跑（不传才会丢掉全部上下文，前面的调研和代码全白做，还可能重复踩已解决过的坑）。
+- ❌ **不要在压缩失败时反复用同一个 session 续跑** —— 同样的超限会再发生一次，徒增 token 消耗。压缩失败就走"换新 session（不传 \`sub_session_id\`）+ 明确列出已完成项/断点/小目标"的兜底路径。
+- ❌ **不要在 session 规模很大时死磕 \`compact_session\`** —— 先按第 0 步评估，message 数很多就走兜底路径（压缩复查 → 仍无效才换新 session）。
 - ❌ **不要用 \`compact_session\` 压缩当前会话自己** —— 工具会直接拒绝（自毁）。
 - ❌ **不要压缩还在 running/pending 的后台任务** —— 先 \`stop_task\`。
 

package/dist/shared/@ai-setting/{roy-agent-core-cpcd24n2.js → roy-agent-core-yet36q5k.js}

@@ -1,9 +1,9 @@
 import {
   init_context
-} from "./roy-agent-core-qqaak24r.js";
+} from "./roy-agent-core-tkpp1ba0.js";
 import {
   getEnvContext
-} from "./roy-agent-core-7cbpmk4q.js";
+} from "./roy-agent-core-p31ftgq9.js";
 import {
   __esm
 } from "./roy-agent-core-fs0mn2jk.js";

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

@@ -1,13 +1,13 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-dqxec05w.js";
+} from "./roy-agent-core-bjtc9d35.js";
 import"./roy-agent-core-1db4vpc6.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";
-import"./roy-agent-core-qq96p0tj.js";
+import"./roy-agent-core-yet36q5k.js";
+import"./roy-agent-core-tkpp1ba0.js";
+import"./roy-agent-core-p31ftgq9.js";
+import"./roy-agent-core-5s2t8z00.js";
 import"./roy-agent-core-7f7t9wwp.js";
 import"./roy-agent-core-85xyctnb.js";
 import"./roy-agent-core-fs0mn2jk.js";

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

@@ -0,0 +1,352 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-7f7t9wwp.js";
+
+// src/env/task/storage/remote-task-store.ts
+init_logger();
+
+class RemoteTaskStoreError extends Error {
+  endpoint;
+  cause;
+  constructor(message, endpoint, cause) {
+    super(message);
+    this.endpoint = endpoint;
+    this.cause = cause;
+    this.name = new.target.name;
+  }
+}
+
+class RemoteAuthError extends RemoteTaskStoreError {
+}
+
+class RemoteIdempotencyConflictError extends RemoteTaskStoreError {
+}
+
+class RemoteBatchBusyError extends RemoteTaskStoreError {
+}
+
+class RemoteProtocolError extends RemoteTaskStoreError {
+}
+var WRITE_METHODS = new Set([
+  "createTask",
+  "updateTask",
+  "deleteTask",
+  "createOperation",
+  "updateOperation",
+  "deleteOperation",
+  "createTag",
+  "deleteTag",
+  "addTagsToTask",
+  "removeTagsFromTask",
+  "updateTaskTags"
+]);
+var REMOTE_TASK_STORE_METHODS = [
+  "createTask",
+  "getTask",
+  "updateTask",
+  "deleteTask",
+  "listTasks",
+  "getTaskIdBySessionId",
+  "getTaskIdsBySessionId",
+  "createOperation",
+  "getOperation",
+  "updateOperation",
+  "deleteOperation",
+  "listOperations",
+  "listOperationsFresh",
+  "invalidateOperationsCache",
+  "createTag",
+  "getTag",
+  "getTagByName",
+  "listTags",
+  "searchTags",
+  "deleteTag",
+  "addTagsToTask",
+  "removeTagsFromTask",
+  "getTagsForTask",
+  "getTaskIdsByTags",
+  "updateTaskTags",
+  "searchTasksByKeywords",
+  "findSimilarTasksByKeywords",
+  "getTaskTree",
+  "getChildTasks",
+  "findSimilarTasks",
+  "searchTasks",
+  "findTasksByContextValue"
+];
+var REMOTE_PROTOCOL_MAJOR = 1;
+function trimTrailingNullish(args) {
+  let end = args.length;
+  while (end > 0) {
+    const v = args[end - 1];
+    if (v === null || v === undefined)
+      end -= 1;
+    else
+      break;
+  }
+  return end === args.length ? args : args.slice(0, end);
+}
+var defaultLog = createLogger("task-remote");
+
+class RemoteTaskStore {
+  endpoint;
+  authToken;
+  timeoutMs;
+  maxRetries;
+  retryBaseDelayMs;
+  fetchImpl;
+  log;
+  stats = { handshakes: 0, requests: 0, retries: 0 };
+  handshake;
+  closed = false;
+  constructor(options) {
+    if (!options?.endpoint) {
+      throw new Error("[RemoteTaskStore] endpoint is required (task.storage.endpoint)");
+    }
+    this.endpoint = options.endpoint.replace(/\/+$/, "");
+    this.authToken = options.authToken;
+    this.timeoutMs = options.timeoutMs ?? 5000;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryBaseDelayMs = options.retryBaseDelayMs ?? 200;
+    this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    this.log = options.log ?? defaultLog;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new RemoteTaskStoreError(`RemoteTaskStore is closed (endpoint=${this.endpoint})`, this.endpoint);
+    }
+  }
+  async ensureHandshake() {
+    if (!this.handshake) {
+      this.handshake = this.doHandshake().catch((e) => {
+        this.handshake = undefined;
+        throw e;
+      });
+    }
+    return this.handshake;
+  }
+  async doHandshake() {
+    this.ensureOpen();
+    let res;
+    try {
+      res = await this.fetchWithTimeout(`${this.endpoint}/version`, { method: "GET" });
+    } catch (e) {
+      throw new RemoteTaskStoreError(`Cannot reach task-service at ${this.endpoint} (/version): ` + `${e instanceof Error ? e.message : String(e)}. ` + `Start it (systemctl --user start roy-task-service) or set task.storage.endpoint correctly. ` + `No local fallback is performed by design.`, this.endpoint, e);
+    }
+    if (!res.ok) {
+      throw new RemoteProtocolError(`task-service /version returned HTTP ${res.status} (endpoint=${this.endpoint})`, this.endpoint);
+    }
+    const body = await res.json().catch(() => ({}));
+    const major = body?.protocol?.major;
+    if (typeof major !== "number") {
+      throw new RemoteProtocolError(`task-service /version response has no protocol.major (endpoint=${this.endpoint})`, this.endpoint);
+    }
+    if (major !== REMOTE_PROTOCOL_MAJOR) {
+      throw new RemoteProtocolError(`Protocol mismatch: client speaks store-major ${REMOTE_PROTOCOL_MAJOR}, ` + `task-service speaks ${major} (endpoint=${this.endpoint}). Upgrade one side.`, this.endpoint);
+    }
+    this.stats.handshakes += 1;
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await this.fetchImpl(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  isRetryableStatus(status) {
+    return status === 503 || status === 502 || status === 504 || status >= 500;
+  }
+  async call(method, rawArgs) {
+    this.ensureOpen();
+    await this.ensureHandshake();
+    const args = trimTrailingNullish(rawArgs);
+    const idempotencyKey = WRITE_METHODS.has(method) ? `${method}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}` : undefined;
+    let lastError;
+    for (let attempt = 0;attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        this.stats.retries += 1;
+        const backoff = this.retryBaseDelayMs * 2 ** (attempt - 1);
+        this.log.debug?.(`[RemoteTaskStore] retry ${attempt}/${this.maxRetries} ${method} in ${backoff}ms`);
+        await new Promise((r) => setTimeout(r, backoff));
+      }
+      const headers = { "content-type": "application/json" };
+      if (this.authToken)
+        headers.authorization = `Bearer ${this.authToken}`;
+      if (idempotencyKey)
+        headers["idempotency-key"] = idempotencyKey;
+      this.stats.requests += 1;
+      let res;
+      try {
+        res = await this.fetchWithTimeout(`${this.endpoint}/store/${method}`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ args })
+        });
+      } catch (e) {
+        lastError = e;
+        if (attempt === this.maxRetries) {
+          throw new RemoteTaskStoreError(`task-service request failed: ${method} (endpoint=${this.endpoint}) after ` + `${attempt + 1} attempts: ${e instanceof Error ? e.message : String(e)}. ` + `No local fallback is performed by design.`, this.endpoint, e);
+        }
+        continue;
+      }
+      if (res.ok) {
+        const text = await res.text();
+        if (!text)
+          return;
+        try {
+          return JSON.parse(text);
+        } catch (e) {
+          throw new RemoteTaskStoreError(`task-service returned non-JSON for ${method} (endpoint=${this.endpoint})`, this.endpoint, e);
+        }
+      }
+      const body = await res.json().catch(() => null);
+      const code = body?.error?.code ?? "";
+      const detail = body?.error?.message ?? `HTTP ${res.status}`;
+      if (res.status === 401) {
+        throw new RemoteAuthError(`task-service rejected the request (401 ${code}): ${detail}. ` + `Check task.storage.authToken against the service's TASK_AUTH_TOKEN ` + `(endpoint=${this.endpoint}).`, this.endpoint);
+      }
+      if (res.status === 409 && code === "IDEMPOTENCY_CONFLICT") {
+        throw new RemoteIdempotencyConflictError(`task-service idempotency conflict for ${method}: ${detail} (endpoint=${this.endpoint})`, this.endpoint);
+      }
+      if (res.status === 404 && code === "METHOD_NOT_FOUND") {
+        throw new RemoteProtocolError(`task-service does not implement ${method}() — service is older than this client ` + `(endpoint=${this.endpoint}). deploy a newer task-service.`, this.endpoint);
+      }
+      if (res.status === 400) {
+        throw new RemoteTaskStoreError(`task-service rejected ${method} payload (400 ${code}): ${detail} (endpoint=${this.endpoint})`, this.endpoint);
+      }
+      if (res.status === 503 && code === "BUSY") {
+        lastError = new RemoteBatchBusyError(`sqlite backend busy for ${method}: a batch transaction holds the single shared ` + `connection; retried ${this.maxRetries} times without success (endpoint=${this.endpoint}). ` + `Retry after the batch completes.`, this.endpoint);
+        if (attempt === this.maxRetries)
+          throw lastError;
+        continue;
+      }
+      if (this.isRetryableStatus(res.status)) {
+        lastError = new RemoteTaskStoreError(`task-service error for ${method} (HTTP ${res.status} ${code}): ${detail} ` + `(endpoint=${this.endpoint})`, this.endpoint);
+        if (attempt === this.maxRetries)
+          throw lastError;
+        continue;
+      }
+      throw new RemoteTaskStoreError(`task-service rejected ${method} (HTTP ${res.status} ${code}): ${detail} ` + `(endpoint=${this.endpoint})`, this.endpoint);
+    }
+    throw new RemoteTaskStoreError(`task-service call ${method} exhausted retries (endpoint=${this.endpoint}): ` + `${lastError instanceof Error ? lastError.message : String(lastError)}`, this.endpoint, lastError);
+  }
+  createTask(options) {
+    return this.call("createTask", [options]);
+  }
+  async getTask(id) {
+    const task = await this.call("getTask", [id]);
+    return task ?? undefined;
+  }
+  async updateTask(id, options) {
+    const task = await this.call("updateTask", [id, options]);
+    return task ?? undefined;
+  }
+  deleteTask(id) {
+    return this.call("deleteTask", [id]);
+  }
+  listTasks(options) {
+    return this.call("listTasks", [options]);
+  }
+  async getTaskIdBySessionId(sessionId) {
+    const id = await this.call("getTaskIdBySessionId", [sessionId]);
+    return id ?? undefined;
+  }
+  getTaskIdsBySessionId(sessionId) {
+    return this.call("getTaskIdsBySessionId", [sessionId]);
+  }
+  createOperation(options) {
+    return this.call("createOperation", [options]);
+  }
+  async getOperation(id) {
+    const op = await this.call("getOperation", [id]);
+    return op ?? undefined;
+  }
+  async updateOperation(id, updates) {
+    const op = await this.call("updateOperation", [id, updates]);
+    return op ?? undefined;
+  }
+  deleteOperation(id) {
+    return this.call("deleteOperation", [id]);
+  }
+  listOperations(options) {
+    return this.call("listOperations", [options]);
+  }
+  listOperationsFresh(options) {
+    return this.call("listOperationsFresh", [options]);
+  }
+  invalidateOperationsCache(taskId) {
+    this.call("invalidateOperationsCache", [taskId]).catch((e) => {
+      this.log.warn?.(`[RemoteTaskStore] invalidateOperationsCache(${taskId}) failed: ` + `${e instanceof Error ? e.message : String(e)}`);
+    });
+  }
+  createTag(name) {
+    return this.call("createTag", [name]);
+  }
+  async getTag(id) {
+    const tag = await this.call("getTag", [id]);
+    return tag ?? undefined;
+  }
+  async getTagByName(name) {
+    const tag = await this.call("getTagByName", [name]);
+    return tag ?? undefined;
+  }
+  listTags(options) {
+    return this.call("listTags", [options]);
+  }
+  searchTags(options) {
+    return this.call("searchTags", [options]);
+  }
+  deleteTag(id) {
+    return this.call("deleteTag", [id]);
+  }
+  async addTagsToTask(taskId, tagIds) {
+    await this.call("addTagsToTask", [taskId, tagIds]);
+  }
+  async removeTagsFromTask(taskId, tagIds) {
+    await this.call("removeTagsFromTask", [taskId, tagIds]);
+  }
+  getTagsForTask(taskId) {
+    return this.call("getTagsForTask", [taskId]);
+  }
+  getTaskIdsByTags(tagNames) {
+    return this.call("getTaskIdsByTags", [tagNames]);
+  }
+  async updateTaskTags(taskId, tagNames) {
+    await this.call("updateTaskTags", [taskId, tagNames]);
+  }
+  searchTasksByKeywords(keywords, options) {
+    return this.call("searchTasksByKeywords", [keywords, options]);
+  }
+  findSimilarTasksByKeywords(keywords, options) {
+    return this.call("findSimilarTasksByKeywords", [keywords, options]);
+  }
+  getTaskTree(taskId, depth) {
+    return this.call("getTaskTree", [taskId, depth]);
+  }
+  getChildTasks(taskId, options) {
+    return this.call("getChildTasks", [taskId, options]);
+  }
+  findSimilarTasks(taskId, limit) {
+    return this.call("findSimilarTasks", [taskId, limit]);
+  }
+  searchTasks(query, limit) {
+    return this.call("searchTasks", [query, limit]);
+  }
+  findTasksByContextValue(value, limit) {
+    return this.call("findTasksByContextValue", [value, limit]);
+  }
+  close() {
+    this.closed = true;
+  }
+}
+function createRemoteTaskStore(options) {
+  return new RemoteTaskStore(options);
+}
+
+export { RemoteTaskStoreError, RemoteAuthError, RemoteIdempotencyConflictError, RemoteBatchBusyError, RemoteProtocolError, REMOTE_TASK_STORE_METHODS, REMOTE_PROTOCOL_MAJOR, RemoteTaskStore, createRemoteTaskStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.7.85",
+  "version": "1.7.89",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",
@@ -72,6 +72,14 @@
       "types": "./dist/env/event-source/wecom-respond-registry.d.ts",
       "default": "./dist/env/event-source/wecom-respond-registry.js"
     },
+    "./env/event-source/wecom-session-card-sender": {
+      "import": "./dist/env/event-source/wecom-session-card-sender.js",
+      "types": "./dist/env/event-source/wecom-session-card-sender.d.ts"
+    },
+    "./env/task/plugins/wecom-session-card-store": {
+      "import": "./dist/env/task/plugins/wecom-session-card-store.js",
+      "types": "./dist/env/task/plugins/wecom-session-card-store.d.ts"
+    },
     "./env/event-source/idempotency-key": {
       "import": "./dist/env/event-source/idempotency-key.js",
       "types": "./dist/env/event-source/idempotency-key.d.ts",