@ai-setting/roy-agent-core 1.5.88 → 1.5.90

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

@@ -0,0 +1,116 @@
+import {
+  init_decorator,
+  wrapFunction
+} from "./roy-agent-core-k05v31rc.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-shme7set.js";
+
+// src/env/task/plugins/auto-task-plugin.ts
+init_logger();
+init_decorator();
+var logger = createLogger("AutoTaskPlugin");
+var AUTO_TASK_METADATA_BEGIN = `
+[[AUTO_TASK_METADATA_BEGIN]]
+`;
+var AUTO_TASK_METADATA_END = `[[AUTO_TASK_METADATA_END]]
+`;
+function wrapAutoTaskMetadata(content) {
+  return `${AUTO_TASK_METADATA_BEGIN}${content}${AUTO_TASK_METADATA_END}`;
+}
+function createAutoTaskPlugin(config) {
+  const threshold = config?.threshold ?? 20;
+  const agentName = config?.agentName ?? "default";
+  const agentComponent = config?.agentComponent ?? null;
+  const subagentType = config?.subagentType ?? "task-agent";
+  let lastProcessedTraceId = "";
+  async function executeImpl(ctx) {
+    try {
+      logger.debug(`[AutoTaskPlugin] agentName=${ctx.agent.name} (expected=${agentName})`);
+      if (ctx.agent.name !== agentName)
+        return { continue: true };
+      logger.debug(`[AutoTaskPlugin] iteration=${ctx.iteration} (threshold=${threshold})`);
+      if (ctx.iteration !== threshold)
+        return { continue: true };
+      const traceId = ctx.context?.traceId ?? ctx.context?.sessionId ?? "unknown";
+      const sid = ctx.context?.sessionId ?? "unknown";
+      if (traceId === lastProcessedTraceId) {
+        logger.debug(`[AutoTaskPlugin] skip - traceId=${traceId.slice(0, 20)}... already processed`);
+        return { continue: true };
+      }
+      lastProcessedTraceId = traceId;
+      logger.debug(`[AutoTaskPlugin] new query detected (traceId=${traceId.slice(0, 20)}...)`);
+      if (!agentComponent || typeof agentComponent.run !== "function") {
+        logger.warn(`[AutoTaskPlugin] agentComponent not provided or invalid (session=${sid.slice(0, 12)}...)`);
+        return { continue: true };
+      }
+      let userQuery = "";
+      for (let i = ctx.messages.length - 1;i >= 0; i--) {
+        const m = ctx.messages[i];
+        if (m.role === "user") {
+          userQuery = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+          break;
+        }
+      }
+      if (!userQuery) {
+        userQuery = "分析项目结构并执行相关任务";
+      }
+      logger.info(`[AutoTaskPlugin] Calling agentComponent.run("${subagentType}") at iteration ${ctx.iteration} (session=${sid.slice(0, 12)}..., persistSession=false)`);
+      const shortDesc = typeof userQuery === "string" ? userQuery.slice(0, 50) : "分析需求";
+      const placeholderContent = `⏳ **${subagentType} 正在执行**: ${shortDesc}（等待结果...）`;
+      const placeholderBlock = wrapAutoTaskMetadata(placeholderContent);
+      if (ctx.toolResult?.result?.output !== undefined) {
+        const originalOutput = ctx.toolResult.result.output;
+        ctx.toolResult.result.output = placeholderBlock + `
+
+` + originalOutput;
+        logger.info(`[AutoTaskPlugin] placeholder prepended (session=${sid.slice(0, 12)}...)`);
+      }
+      let taskAgentFinalText = "";
+      try {
+        const taskAgentResult = await agentComponent.run(subagentType, userQuery, {
+          sessionId: sid,
+          traceId,
+          persistSession: false
+        });
+        taskAgentFinalText = taskAgentResult?.finalText || "";
+        logger.info(`[AutoTaskPlugin] task-agent completed (session=${sid.slice(0, 12)}..., finalTextLength=${taskAgentFinalText.length})`);
+      } catch (err) {
+        logger.error(`[AutoTaskPlugin] task-agent failed: ${err instanceof Error ? err.message : String(err)}`);
+        taskAgentFinalText = `❌ **${subagentType} 执行失败**: ${err instanceof Error ? err.message : String(err)}`;
+      }
+      if (taskAgentFinalText && ctx.toolResult?.result?.output !== undefined) {
+        const finalBlock = wrapAutoTaskMetadata(taskAgentFinalText);
+        const current = ctx.toolResult.result.output;
+        const updated = placeholderBlock && current.includes(placeholderBlock) ? current.replace(placeholderBlock, finalBlock) : finalBlock + `
+
+` + current;
+        ctx.toolResult.result.output = updated;
+        logger.info(`[AutoTaskPlugin] task-agent finalText injected (session=${sid.slice(0, 12)}...)`);
+      } else if (!ctx.toolResult?.result?.output) {
+        logger.warn(`[AutoTaskPlugin] toolResult unavailable for injection`);
+      }
+      return { continue: true };
+    } catch (err) {
+      logger.error(`[AutoTaskPlugin] hook failed: ${err instanceof Error ? err.message : String(err)}`);
+      return { continue: true };
+    }
+  }
+  const execute = wrapFunction(executeImpl, "plugin.auto-task.launch-agent", {
+    recordParams: false,
+    recordResult: true,
+    log: true
+  });
+  return {
+    name: "AutoTaskPlugin",
+    version: "4.6.0",
+    description: "ReAct iteration 达到阈值时 await task-agent 执行并提取 delegate_task 结果注入 tool result",
+    hooks: [
+      { point: "agent:after.tool", priority: 50 }
+    ],
+    execute
+  };
+}
+
+export { AUTO_TASK_METADATA_BEGIN, AUTO_TASK_METADATA_END, createAutoTaskPlugin };

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

@@ -8,7 +8,22 @@ import {
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/nodes/tool-node.ts
-var ToolNode;
+function isPositiveNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+function getToolTimeoutMs(input, config) {
+  if (input && typeof input === "object") {
+    const inputTimeout = input.timeout;
+    if (isPositiveNumber(inputTimeout)) {
+      return inputTimeout;
+    }
+  }
+  if (config && isPositiveNumber(config.timeout)) {
+    return config.timeout;
+  }
+  return DEFAULT_TOOL_TIMEOUT_MS;
+}
+var DEFAULT_TOOL_TIMEOUT_MS = 60000, ToolNode;
 var init_tool_node = __esm(() => {
   init_decorator();
   ToolNode = class ToolNode {
@@ -88,11 +103,20 @@ var init_tool_node = __esm(() => {
               nodeId: context.nodeId
             }
           };
+          const toolTimeoutMs = getToolTimeoutMs(input, this.definition.config);
           const executePromise = tool.execute(input, toolContext);
+          let timeoutHandle;
           const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`Tool '${toolName}' execution timeout after 60 seconds`)), 60000);
+            timeoutHandle = setTimeout(() => reject(new Error(`Tool '${toolName}' execution timeout after ${Math.round(toolTimeoutMs / 1000)} seconds`)), toolTimeoutMs);
           });
-          output = await Promise.race([executePromise, timeoutPromise]);
+          try {
+            output = await Promise.race([executePromise, timeoutPromise]);
+          } finally {
+            if (timeoutHandle !== undefined) {
+              clearTimeout(timeoutHandle);
+              timeoutHandle = undefined;
+            }
+          }
         } catch (toolError) {
           if (toolError instanceof TypeError && toolError.message.includes("context") && toolError.message.includes("not a function")) {
             output = await tool.execute(input);

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

@@ -1,10 +1,27 @@
 import {
   SessionMessageConverter
-} from "./roy-agent-core-c1j7ev4e.js";
+} from "./roy-agent-core-txwf64pd.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-shme7set.js";
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
+// src/env/session/session-store.ts
+class BaseSessionStore {
+  async addMessages(sessionId, messages) {
+    if (messages.length === 0)
+      return [];
+    const ids = [];
+    for (const msg of messages) {
+      ids.push(await this.addMessage(sessionId, msg));
+    }
+    return ids;
+  }
+}
+
 // src/env/session/storage/memory.ts
 import { randomUUID } from "crypto";
 function generateSessionId() {
@@ -14,7 +31,7 @@ function generateMessageId() {
   return `msg_${randomUUID()}`;
 }
 
-class MemorySessionStore {
+class MemorySessionStore extends BaseSessionStore {
   sessions = new Map;
   messages = new Map;
   checkpoints = new Map;
@@ -138,6 +155,40 @@ class MemorySessionStore {
     session.updatedAt = Date.now();
     return msg.id;
   }
+  async addMessages(sessionId, messages) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const sessionMessages = this.messages.get(sessionId) ?? [];
+    const ids = [];
+    const now = Date.now();
+    for (const message of messages) {
+      const rawMessage = {
+        sessionID: sessionId,
+        role: message.role,
+        content: message.content,
+        parts: message.parts,
+        metadata: message.metadata
+      };
+      const msg = this.messageConverter.migrateMessage(rawMessage);
+      msg.id = generateMessageId();
+      msg.timestamp = now;
+      sessionMessages.push(msg);
+      ids.push(msg.id);
+    }
+    this.messages.set(sessionId, sessionMessages);
+    session.messageCount = sessionMessages.filter((m) => !m.isArchived).length;
+    session.metadata = {
+      ...session.metadata,
+      messageCount: session.messageCount
+    };
+    session.updatedAt = now;
+    return ids;
+  }
   async updateMessage(sessionId, messageId, updates) {
     const sessionMessages = this.messages.get(sessionId);
     if (!sessionMessages) {
@@ -371,6 +422,8 @@ class MemorySessionStore {
 // src/env/session/storage/sqlite.ts
 import { join } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
+init_logger();
+var logger = createLogger("session:storage:sqlite");
 function getDatabaseClass() {
   if (typeof Bun !== "undefined") {
     const { Database } = __require("bun:sqlite");
@@ -379,6 +432,17 @@ function getDatabaseClass() {
     return __require("better-sqlite3");
   }
 }
+function isSqliteBusyError(err) {
+  if (err == null)
+    return false;
+  const e = err;
+  if (typeof e.code === "string" && /^SQLITE_(BUSY|LOCKED)$/i.test(e.code))
+    return true;
+  if (typeof e.errno === "number" && (e.errno === 5 || e.errno === 6))
+    return true;
+  const msg = e.message ?? "";
+  return /SQLiteError:\s+(database is locked|database table is locked)/i.test(msg);
+}
 function createCompatibleDatabase(path) {
   const Database = getDatabaseClass();
   const db = new Database(path);
@@ -407,7 +471,7 @@ function getDefaultSessionDbPath() {
   return join(getDefaultDataDir(), "roy-agent", "sessions.db");
 }
 
-class SQLiteSessionStore {
+class SQLiteSessionStore extends BaseSessionStore {
   db = null;
   dbPath;
   initialized = false;
@@ -416,6 +480,7 @@ class SQLiteSessionStore {
   checkpointsCache = new Map;
   messageConverter = new SessionMessageConverter;
   constructor(dbPath) {
+    super();
     this.dbPath = dbPath || getDefaultSessionDbPath();
   }
   async initialize() {
@@ -430,6 +495,10 @@ class SQLiteSessionStore {
       }
     }
     this.db = createCompatibleDatabase(this.dbPath);
+    this.applyPragma("PRAGMA journal_mode = WAL");
+    this.applyPragma("PRAGMA busy_timeout = 5000");
+    this.applyPragma("PRAGMA synchronous = NORMAL");
+    this.applyPragma("PRAGMA wal_autocheckpoint = 1000");
     this.db.run(`
       CREATE TABLE IF NOT EXISTS session (
         id TEXT PRIMARY KEY,
@@ -611,6 +680,90 @@ class SQLiteSessionStore {
     this.sessionsCache.set(sessionId, session);
     return msg.id;
   }
+  async addMessages(sessionId, messages) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const BATCH_BACKOFFS_MS = [50, 100, 200];
+    let lastError = undefined;
+    for (let attempt = 0;attempt <= BATCH_BACKOFFS_MS.length; attempt++) {
+      try {
+        return await this.addMessagesOnce(sessionId, messages);
+      } catch (err) {
+        if (!isSqliteBusyError(err) || attempt === BATCH_BACKOFFS_MS.length) {
+          this.messagesCache.delete(sessionId);
+          this.sessionsCache.delete(sessionId);
+          lastError = err;
+          if (!isSqliteBusyError(err))
+            throw err;
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, BATCH_BACKOFFS_MS[attempt]));
+      }
+    }
+    throw lastError;
+  }
+  async addMessagesOnce(sessionId, messages) {
+    await this.initialize();
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const now = Date.now();
+    const ids = [];
+    const insertStmt = this.db.prepare(`
+      INSERT INTO message (id, session_id, role, content, timestamp, parts, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    const sessionUpdateStmt = this.db.prepare(`
+      UPDATE session SET message_count = ?, metadata = ?, updated_at = ? WHERE id = ?
+    `);
+    this.db.run("BEGIN");
+    try {
+      for (const message of messages) {
+        const id = generateMessageId2();
+        ids.push(id);
+        insertStmt.run(id, sessionId, message.role, message.content, now, message.parts ? JSON.stringify(message.parts) : null, message.metadata ? JSON.stringify(message.metadata) : null);
+      }
+      const countResult = this.db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0").get(sessionId);
+      const newCount = countResult?.count ?? 0;
+      session.messageCount = newCount;
+      session.updatedAt = now;
+      session.metadata = {
+        ...session.metadata ?? {},
+        messageCount: newCount
+      };
+      sessionUpdateStmt.run(newCount, JSON.stringify(session.metadata), now, sessionId);
+      this.db.run("COMMIT");
+    } catch (err) {
+      try {
+        this.db.run("ROLLBACK");
+      } catch {}
+      throw err;
+    }
+    try {
+      const cached = this.messagesCache.get(sessionId) ?? [];
+      for (let i = 0;i < messages.length; i++) {
+        const message = messages[i];
+        cached.push({
+          id: ids[i],
+          sessionID: sessionId,
+          role: message.role,
+          content: message.content,
+          timestamp: now,
+          parts: message.parts,
+          metadata: message.metadata
+        });
+      }
+      this.messagesCache.set(sessionId, cached);
+      this.sessionsCache.set(sessionId, session);
+    } catch (cacheErr) {
+      logger.warn(`[SQLiteSessionStore] cache update failed after commit; invalidating: ${cacheErr}`);
+      this.messagesCache.delete(sessionId);
+      this.sessionsCache.delete(sessionId);
+    }
+    return ids;
+  }
   async updateMessage(sessionId, messageId, updates) {
     await this.initialize();
     const row = this.db.prepare("SELECT id FROM message WHERE id = ? AND session_id = ?").get(messageId, sessionId);
@@ -679,6 +832,13 @@ class SQLiteSessionStore {
     const rows = this.db.prepare(sql).all(...params);
     return rows.map((row) => this.rowToMessage(row));
   }
+  applyPragma(pragmaSql) {
+    this.db.run(pragmaSql);
+    const readback = this.db.prepare(pragmaSql.split("=")[0].trim()).get();
+    const key = Object.keys(readback ?? {})[0];
+    const actual = key ? readback[key] : undefined;
+    logger.info(`[SQLiteSessionStore] Applied ${pragmaSql} → ${actual}`);
+  }
   async getMessageCount(sessionId, includeArchived = false) {
     await this.initialize();
     let sql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.88",
+  "version": "1.5.90",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",