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

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

@@ -0,0 +1,35 @@
+import {
+  DAGManager,
+  init_dag_manager
+} from "./roy-agent-core-4yq23m5g.js";
+
+// src/env/workflow/utils/validate-workflow-definition.ts
+init_dag_manager();
+function validateWorkflowDefinition(definition) {
+  if (!definition || typeof definition !== "object") {
+    return {
+      valid: false,
+      errors: ["Workflow definition must be an object"]
+    };
+  }
+  const def = definition;
+  if (!Array.isArray(def.nodes)) {
+    return {
+      valid: false,
+      errors: ["Workflow definition must have a 'nodes' array"]
+    };
+  }
+  try {
+    const dag = new DAGManager(definition, { allowCycles: false });
+    return dag.validate();
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        `Validation error: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+}
+
+export { validateWorkflowDefinition };

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

@@ -1,19 +1,22 @@
 import {
   withTimeout
-} from "./roy-agent-core-r0m0at3x.js";
+} from "./roy-agent-core-0r4ndyn9.js";
+import {
+  truncateOutputInline
+} from "./roy-agent-core-hxsbegfc.js";
 import {
   AskUserError,
   init_workflow_hil
 } from "./roy-agent-core-e25xkv53.js";
 import {
   AgentRegistry
-} from "./roy-agent-core-7z4xtrmw.js";
+} from "./roy-agent-core-nqzt9ne4.js";
 import {
   ContextError
 } from "./roy-agent-core-ctdhjv68.js";
 import {
   SessionMessageConverter
-} from "./roy-agent-core-c1j7ev4e.js";
+} from "./roy-agent-core-txwf64pd.js";
 import {
   safeParseToolArgs
 } from "./roy-agent-core-ce10b0ez.js";
@@ -112,23 +115,53 @@ function toLLMMessage(msg) {
       toolName = toolResult?.toolName;
     } else {
       const toolCallParts = msg.content.filter((part) => part.type === "tool-call");
-      const contentParts = msg.content.filter((part) => part.type === "text").map((part) => part.text || "");
-      content = contentParts.join(`
+      const hasMultimodalPart = msg.content.some((part) => part.type === "image" || part.type === "file");
+      if (hasMultimodalPart) {
+        const llmContentParts = [];
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            llmContentParts.push({ type: "text", text: part.text || "" });
+          } else if (part.type === "image") {
+            llmContentParts.push({ type: "image", image: part.image });
+          } else if (part.type === "file") {
+            llmContentParts.push({
+              type: "file",
+              file: part.data ?? part.file,
+              mediaType: part.mediaType || "application/octet-stream"
+            });
+          }
+        }
+        if (msg.role === "assistant" && toolCallParts.length > 0) {
+          for (const part of toolCallParts) {
+            const argsString = typeof part.input === "string" ? part.input : JSON.stringify(part.input || {});
+            toolCalls = (toolCalls ?? []).concat([{
+              id: part.toolCallId,
+              name: part.toolName || "unknown",
+              arguments: argsString,
+              function: { name: part.toolName || "unknown", arguments: argsString }
+            }]);
+          }
+        }
+        content = llmContentParts;
+      } else {
+        const contentParts = msg.content.filter((part) => part.type === "text").map((part) => part.text || "");
+        content = contentParts.join(`
 `);
-      if (msg.role === "assistant" && toolCallParts.length > 0) {
-        toolCalls = toolCallParts.map((part) => {
-          const argsString = typeof part.input === "string" ? part.input : JSON.stringify(part.input || {});
-          const toolName2 = part.toolName || "unknown";
-          return {
-            id: part.toolCallId,
-            name: toolName2,
-            arguments: argsString,
-            function: {
+        if (msg.role === "assistant" && toolCallParts.length > 0) {
+          toolCalls = toolCallParts.map((part) => {
+            const argsString = typeof part.input === "string" ? part.input : JSON.stringify(part.input || {});
+            const toolName2 = part.toolName || "unknown";
+            return {
+              id: part.toolCallId,
               name: toolName2,
-              arguments: argsString
-            }
-          };
-        });
+              arguments: argsString,
+              function: {
+                name: toolName2,
+                arguments: argsString
+              }
+            };
+          });
+        }
       }
     }
   } else {
@@ -303,6 +336,12 @@ class AgentComponent extends BaseComponent {
       logger.info("[AgentComponent] Registered built-in workflow-agent");
       this.registry.registerJsonExtractAgent();
       logger.info("[AgentComponent] Registered built-in json-extract agent");
+      this.registry.registerWorkflowExtractAgent();
+      logger.info("[AgentComponent] Registered built-in workflow-extract agent");
+      this.registry.registerCompactAgent();
+      logger.info("[AgentComponent] Registered built-in compact agent");
+      this.registry.registerCompactHintAgent();
+      logger.info("[AgentComponent] Registered built-in compact-hint agent");
       for (const agentDef of this.registry.list()) {
         if (!this.agents.has(agentDef.name)) {
           const systemPrompt = await this.registry.getSystemPrompt(agentDef.name);
@@ -504,7 +543,7 @@ class AgentComponent extends BaseComponent {
     const allowedTools = context?.allowedTools ?? agent.config.allowedTools;
     const deniedTools = context?.deniedTools ?? agent.config.deniedTools;
     logger.debug(`[getAvailableTools] Filtering: allowed=${allowedTools}, denied=${deniedTools}`);
-    if (allowedTools?.length) {
+    if (allowedTools !== undefined && allowedTools !== null) {
       tools = tools.filter((t) => allowedTools.includes(t.name));
       logger.debug(`[getAvailableTools] After allowedTools filter: ${tools.length} tools`, {
         toolNames: tools.map((t) => t.name)
@@ -541,7 +580,8 @@ class AgentComponent extends BaseComponent {
       throw new Error(`Agent not found: ${agentName}`);
     }
     const runId = `${agentName}:${++this.runCounter}`;
-    logger.info(`Starting agent run: ${agentName} (runId=${runId})`, { query: query.substring(0, 100) });
+    const querySummary = typeof query === "string" ? query.substring(0, 100) : query.filter((p) => p.type === "text").map((p) => p.text).join(" ").substring(0, 100) || "[multimodal query]";
+    logger.info(`Starting agent run: ${agentName} (runId=${runId})`, { query: querySummary });
     agent.status = "running";
     this.aborted.set(runId, false);
     const abortController = new AbortController;
@@ -550,24 +590,25 @@ class AgentComponent extends BaseComponent {
       this.doomLoopCaches.set(runId, new Map);
     }
     await this.resolveSystemPrompt(agent, agentName);
+    let resolvedSystemPrompt;
     if (agent.config.systemPrompt) {
-      const sp = agent.config.systemPrompt;
-      if (sp.includes("{{workspace_dir}}")) {
+      resolvedSystemPrompt = agent.config.systemPrompt;
+      if (resolvedSystemPrompt.includes("{{workspace_dir}}")) {
         const workspaceDir = this.env?.getComponent?.("config")?.get?.("workspace_dir") || process.cwd();
-        agent.config.systemPrompt = agent.config.systemPrompt.replaceAll("{{workspace_dir}}", String(workspaceDir));
+        resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{workspace_dir}}", String(workspaceDir));
       }
-      if (sp.includes("{{memory}}")) {
+      if (resolvedSystemPrompt.includes("{{memory}}")) {
         try {
           const memoryComponent = this.env?.getComponent?.("memory");
           if (memoryComponent && typeof memoryComponent.recallMemory === "function") {
             const memoryContent = await memoryComponent.recallMemory();
-            agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", memoryContent || "(No memory)");
+            resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", memoryContent || "(No memory)");
           } else {
-            agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", "(Memory component not available)");
+            resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", "(Memory component not available)");
           }
         } catch (err) {
           logger.warn(`[AgentComponent._run] Failed to replace {{memory}}: ${err}`);
-          agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", "(Failed to load memory)");
+          resolvedSystemPrompt = resolvedSystemPrompt.replaceAll("{{memory}}", "(Failed to load memory)");
         }
       }
     }
@@ -588,7 +629,7 @@ class AgentComponent extends BaseComponent {
       maxIterations: agent.config.maxIterations,
       messages: [],
       tools: this.getAvailableTools(agent, effectiveContext),
-      systemPrompt: agent.config.systemPrompt || "You are a helpful assistant.",
+      systemPrompt: resolvedSystemPrompt ?? agent.config.systemPrompt ?? "You are a helpful assistant.",
       context: effectiveContext
     };
     let historyMessageCount = 0;
@@ -960,6 +1001,7 @@ class AgentComponent extends BaseComponent {
       }
       this.aborted.delete(runId);
       this.abortControllers.delete(runId);
+      this.doomLoopCaches.delete(runId);
       if (result.error) {
         this.pushEnvEvent({
           type: "agent.error",
@@ -1062,7 +1104,8 @@ ${additionInfo}`
             sessionId: ctx.context.sessionId,
             messageId: ctx.context.messageId
           },
-          abortSignal: ctx.context.abort
+          abortSignal: ctx.context.abort,
+          skipThresholdCheck: ctx.context.agentType === "sub"
         });
         const result = await withTimeout(llmPromise, 300000, "LLM invocation timeout after 300s");
         logger.debug("[invokeLLM] LLMComponent.invoke returned successfully");
@@ -1148,6 +1191,7 @@ ${additionInfo}`
         } else {
           result = await withTimeout(toolPromise, 120000, `Tool '${toolName}' execution timeout after 120s`);
         }
+        result = truncateOutputInline(result, undefined, undefined, toolName);
       } else if (this.toolComponent?.execute) {
         const toolPromise = this.toolComponent.execute(request);
         if (isLongRunningTool) {
@@ -1163,6 +1207,7 @@ ${additionInfo}`
         } else {
           result = await withTimeout(toolPromise, 120000, `Tool '${toolName}' execution timeout after 120s`);
         }
+        result = truncateOutputInline(result, undefined, undefined, toolName);
       }
       this.pushEnvEvent({
         type: "tool.result",
@@ -1280,6 +1325,7 @@ ${additionInfo}`
         logger.warn("SessionComponent not found, skipping session recording");
         return;
       }
+      const filtered2 = [];
       for (const msg of allMessages) {
         if (msg.role === "system") {
           continue;
@@ -1292,10 +1338,19 @@ ${additionInfo}`
             continue;
           }
         }
-        await sessionComponent.addMessage(sessionId, this.messageConverter.fromModelMessage(msg, { sessionID: sessionId }));
+        filtered2.push(this.messageConverter.fromModelMessage(msg, { sessionID: sessionId }));
+      }
+      if (filtered2.length === 0) {
+        return;
       }
+      await sessionComponent.addMessages(sessionId, filtered2);
     } catch (err) {
-      logger.warn(`Failed to record session messages: ${err}`);
+      const kind = err && typeof err === "object" && "kind" in err ? err.kind : undefined;
+      if (kind === "lock_exhausted") {
+        logger.error(`[recordSessionMessages] DROPPED ${filtered?.length ?? "?"} message(s) — SQLITE_BUSY retry exhausted after ${err.attempts ?? "?"} attempts. Session ${sessionId} is now inconsistent with LLM context. Original: ${err}`);
+      } else {
+        logger.error(`[recordSessionMessages] Failed to record session messages for ${sessionId}: ${err}`);
+      }
     }
   }
   isEmptyMessage(content) {
@@ -1375,4 +1430,19 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   TracedAs("agent.component.getConversationHistory", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "getConversationHistory", null);
-export { AgentComponentConfigSchema, AgentComponent };
+// src/env/agent/summary-agent.ts
+class SummaryAgent {
+  llmComponent;
+  config;
+  constructor(_promptComponent, llmComponent, config) {
+    this.llmComponent = llmComponent;
+    this.config = {
+      type: "summary",
+      promptName: "session/compact",
+      maxIterations: 1,
+      model: undefined,
+      ...config
+    };
+  }
+}
+export { AgentComponentConfigSchema, AgentComponent, SummaryAgent };

package/dist/shared/@ai-setting/{roy-agent-core-29fh9mxg.js → roy-agent-core-bwjpte58.js}

@@ -1,6 +1,6 @@
 import {
   createAutoTaskPlugin
-} from "./roy-agent-core-7fdzfsm6.js";
+} from "./roy-agent-core-yanpq5gb.js";
 import {
   ContextError,
   ErrorCodes
@@ -158,7 +158,6 @@ class BaseEnvironment extends BaseComponent {
         "echo",
         "glob",
         "grep",
-        "read_file",
         "write_file",
         "edit_file",
         "task_create",

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

@@ -6,7 +6,7 @@ import {
   isBuiltInEventSourceType,
   isValidEventSourceType,
   validateEventSourceConfig
-} from "./roy-agent-core-qhhxx2x2.js";
+} from "./roy-agent-core-ds5f75pg.js";
 import"./roy-agent-core-fs0mn2jk.js";
 export {
   validateEventSourceConfig,

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

@@ -1,7 +1,8 @@
 // src/env/event-source/types.ts
 var BUILT_IN_EVENT_SOURCE_TYPES = {
   LARK_CLI: "lark-cli",
-  TIMER: "timer"
+  TIMER: "timer",
+  BOUNTY_IM: "bounty-im"
 };
 var BUILT_IN_EVENT_SOURCE_TYPE_LIST = Object.values(BUILT_IN_EVENT_SOURCE_TYPES);
 

package/dist/shared/@ai-setting/{roy-agent-core-4cdtdxqx.js → roy-agent-core-ewr1nw7t.js}

@@ -5,7 +5,7 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-bgw4dq11.js";
+} from "./roy-agent-core-mw4ty0ba.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath

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

@@ -0,0 +1,114 @@
+// src/env/task/delegate/process-registry.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/util/process/process-tree-killer.ts
+import { spawn as _childProcessSpawn } from "child_process";
+var spawnInjector;
+function spawn(cmd, args, opts) {
+  if (spawnInjector)
+    return spawnInjector(cmd, args, opts);
+  return _childProcessSpawn(cmd, args, opts);
+}
+var platformOverride;
+function currentPlatform() {
+  return platformOverride ?? process.platform;
+}
+function killProcessTree(pid, options) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    throw new Error(`Invalid PID: ${pid} (must be a positive integer)`);
+  }
+  const platform = currentPlatform();
+  const signal = options?.signal ?? "SIGKILL";
+  if (platform === "win32") {
+    return killOnWindows(pid);
+  }
+  return killOnPosix(pid, signal);
+}
+function killOnWindows(pid) {
+  try {
+    spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    return {
+      pid,
+      platform: "win32",
+      signal: "taskkill /f /t",
+      success: true
+    };
+  } catch {
+    return {
+      pid,
+      platform: "win32",
+      signal: "taskkill /f /t",
+      success: false
+    };
+  }
+}
+function killOnPosix(pid, signal) {
+  const platform = currentPlatform();
+  try {
+    process.kill(-pid, signal);
+    return {
+      pid,
+      platform,
+      signal,
+      success: true
+    };
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH" || code === "EPERM") {
+      return {
+        pid,
+        platform,
+        signal,
+        success: true
+      };
+    }
+    return {
+      pid,
+      platform,
+      signal,
+      success: false
+    };
+  }
+}
+
+// src/env/task/delegate/process-registry.ts
+class ProcessRegistry {
+  pids = new Set;
+  register(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      return;
+    }
+    this.pids.add(pid);
+  }
+  unregister(pid) {
+    if (!Number.isInteger(pid)) {
+      return;
+    }
+    this.pids.delete(pid);
+  }
+  size() {
+    return this.pids.size;
+  }
+  killAll() {
+    if (this.pids.size === 0)
+      return;
+    for (const pid of Array.from(this.pids)) {
+      try {
+        killProcessTree(pid);
+      } catch {}
+    }
+    this.pids.clear();
+  }
+}
+var processRegistryStorage = new AsyncLocalStorage;
+function runWithProcessRegistryAsync(registry, fn) {
+  return processRegistryStorage.run(registry, fn);
+}
+function getCurrentProcessRegistry() {
+  return processRegistryStorage.getStore();
+}
+
+export { killProcessTree, ProcessRegistry, runWithProcessRegistryAsync, getCurrentProcessRegistry };