arisa 5.1.66 → 5.2.7

package/src/core/tools/tool-registry.js

@@ -1,21 +1,25 @@
 import { mkdir, readdir, readFile, rmdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { arisaIpcSocketFile, arisaPackageDir, getToolConfigPath, getToolStateDir, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
+import { createHash, randomUUID } from "node:crypto";
+import { getToolConfigPath, getToolStateDir, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../platform/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
 import { readDaemonDiagnostic } from "./daemon-processes.js";
-import { createDaemonRuntime, DAEMON_EVENT_TYPES, DAEMON_PROTOCOL_VERSION } from "./daemon-runtime.js";
+import { createDaemonRuntime } from "./daemon-runtime.js";
 import { daemonConfigDefaults } from "../config/config-defaults.js";
 import { SkillRegistry } from "../skills/skill-registry.js";
 import { ToolUsageStore } from "./tool-usage-store.js";
 import { inspectToolDependencies, normalizeToolDependencies } from "./tool-dependencies.js";
 import { normalizeToolExecution, WeightedResourceGovernor } from "./weighted-resource-governor.js";
+import {
+  isolatedToolProcessInvocation,
+  runToolHelpProcess,
+  runToolProcess,
+  toolProcessEnv
+} from "./tool-process-runner.js";
 
-function toolEnv() {
-  return { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir, ARISA_IPC_SOCKET: arisaIpcSocketFile };
-}
+export { createToolOutputParser } from "./tool-process-output.js";
+export { isolatedToolProcessInvocation } from "./tool-process-runner.js";
 
 const defaultToolHelpTimeoutMs = 10_000;
 const defaultToolRunTimeoutMs = 30 * 60_000;
@@ -25,43 +29,28 @@ function positiveDuration(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 
-function waitForToolProcess(child, { timeoutMs, killGraceMs, label }) {
-  return new Promise((resolve, reject) => {
-    let timedOut = false;
-    let forceTimer = null;
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-      forceTimer = setTimeout(() => child.kill("SIGKILL"), killGraceMs);
-    }, timeoutMs);
-
-    const finish = (callback, value) => {
-      clearTimeout(timeout);
-      clearTimeout(forceTimer);
-      callback(value);
-    };
+function canonicalRequestValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalRequestValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalRequestValue(value[key])]));
+  }
+  return value === undefined ? null : value;
+}
 
-    child.once("error", (error) => finish(reject, error));
-    child.once("close", (code) => {
-      if (!timedOut) {
-        finish(resolve, code);
-        return;
-      }
-      const error = new Error(`${label} timed out after ${timeoutMs}ms`);
-      error.code = "TOOL_PROCESS_TIMEOUT";
-      finish(reject, error);
-    });
-  });
+function concurrentExecutionKey(name, chatId, request) {
+  const serialized = JSON.stringify(canonicalRequestValue({ name, chatId: chatId == null ? null : String(chatId), request }));
+  return createHash("sha256").update(serialized).digest("hex");
 }
 
-async function runProcess(command, args, { timeoutMs, killGraceMs, label, ...options } = {}) {
-  const child = spawn(command, args, { ...options, stdio: ["ignore", "pipe", "pipe"] });
-  let stdout = "";
-  let stderr = "";
-  child.stdout.on("data", (d) => { stdout += d.toString(); });
-  child.stderr.on("data", (d) => { stderr += d.toString(); });
-  const code = await waitForToolProcess(child, { timeoutMs, killGraceMs, label });
-  return { code, stdout, stderr };
+function executionForLease(execution, lease) {
+  if (!execution) return null;
+  return {
+    ...execution,
+    maxHeapMb: lease.heapLimitMb || execution.maxHeapMb,
+    maxMemoryMb: lease.memoryLimitMb || execution.maxMemoryMb,
+    memoryHighPercent: lease.memoryHighPercent,
+    swapMaxMb: lease.swapMaxMb
+  };
 }
 
 function requirementNames(requirements) {
@@ -72,123 +61,6 @@ function requirementNames(requirements) {
   return [];
 }
 
-export function createToolOutputParser(name, { onEvent, maxFrameBytes = 1_048_576 } = {}) {
-  let buffer = "";
-  let mode = "unknown";
-  let rawOutput = "";
-  let terminalResult = null;
-  let activeJobId = null;
-  let sequence = 0;
-  let terminalSeen = false;
-
-  async function parseEvent(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      throw new Error(`Invalid NDJSON from ${name}`);
-    }
-    if (event?.version !== DAEMON_PROTOCOL_VERSION || !DAEMON_EVENT_TYPES.includes(event?.type)) {
-      throw new Error(`Invalid versioned tool event from ${name}`);
-    }
-    if (typeof event.jobId !== "string" || !event.jobId) throw new Error(`Tool event from ${name} is missing jobId`);
-    if (activeJobId == null) activeJobId = event.jobId;
-    if (event.jobId !== activeJobId) throw new Error(`Tool ${name} multiplexed an unexpected jobId`);
-    if (!Number.isSafeInteger(event.sequence) || event.sequence !== sequence + 1) {
-      throw new Error(`Invalid tool event sequence from ${name}: ${event.sequence}`);
-    }
-    if (terminalSeen) throw new Error(`Tool ${name} emitted more than one terminal event`);
-    sequence = event.sequence;
-    terminalSeen = event.type === "completed" || event.type === "failed";
-    await onEvent?.(event);
-    if (terminalSeen) {
-      terminalResult = event.type === "completed"
-        ? event.payload?.result ?? event.payload?.output ?? event.payload
-        : { ok: false, error: event.payload?.error || `Tool failed: ${name}`, ...(event.payload?.code ? { code: event.payload.code } : {}) };
-    }
-  }
-
-  async function consumeLine(line) {
-    if (Buffer.byteLength(line, "utf8") > maxFrameBytes) throw new Error(`Tool event from ${name} exceeds ${maxFrameBytes} bytes`);
-    if (mode === "unknown") {
-      let candidate;
-      try {
-        candidate = JSON.parse(line);
-      } catch {
-        mode = "legacy";
-        return;
-      }
-      if (candidate?.version === DAEMON_PROTOCOL_VERSION && DAEMON_EVENT_TYPES.includes(candidate?.type)) {
-        mode = "ndjson";
-        rawOutput = "";
-        return parseEvent(line);
-      }
-      mode = "legacy";
-      return;
-    }
-    if (mode === "legacy") return;
-    return parseEvent(line);
-  }
-
-  return {
-    async push(chunk) {
-      const text = chunk.toString("utf8");
-      if (mode !== "ndjson") rawOutput += text;
-      if (mode === "legacy") return;
-      buffer += text;
-      if (Buffer.byteLength(buffer, "utf8") > maxFrameBytes && !buffer.includes("\n")) {
-        throw new Error(`Tool event from ${name} exceeds ${maxFrameBytes} bytes`);
-      }
-      let newlineIndex = buffer.indexOf("\n");
-      while (newlineIndex !== -1) {
-        const line = buffer.slice(0, newlineIndex).trim();
-        buffer = buffer.slice(newlineIndex + 1);
-        if (line) await consumeLine(line);
-        newlineIndex = buffer.indexOf("\n");
-      }
-    },
-    async finish() {
-      const tail = buffer.trim();
-      buffer = "";
-      if (tail) await consumeLine(tail);
-      if (mode !== "ndjson") return { mode: "legacy", output: rawOutput };
-      if (!terminalSeen) throw new Error(`Tool ${name} ended without a terminal event`);
-      return { mode: "ndjson", result: terminalResult };
-    }
-  };
-}
-
-async function runToolProcess(command, args, { onEvent, maxFrameBytes, timeoutMs, killGraceMs, label, ...options } = {}) {
-  const child = spawn(command, args, { ...options, stdio: ["ignore", "pipe", "pipe"] });
-  const parser = createToolOutputParser(path.basename(args[0] || command), { onEvent, maxFrameBytes });
-  const stderrChunks = [];
-  let stderrBytes = 0;
-  const stdoutTask = (async () => {
-    for await (const chunk of child.stdout) await parser.push(chunk);
-    return parser.finish();
-  })();
-  const stderrTask = (async () => {
-    for await (const chunk of child.stderr) {
-      if (stderrBytes >= maxFrameBytes) continue;
-      const accepted = chunk.subarray(0, maxFrameBytes - stderrBytes);
-      stderrChunks.push(accepted);
-      stderrBytes += accepted.length;
-    }
-    return Buffer.concat(stderrChunks).toString("utf8");
-  })();
-  child.stdout.resume();
-  child.stderr.resume();
-  let code;
-  try {
-    code = await waitForToolProcess(child, { timeoutMs, killGraceMs, label });
-  } catch (error) {
-    await Promise.allSettled([stdoutTask, stderrTask]);
-    throw error;
-  }
-  const [parsed, stderr] = await Promise.all([stdoutTask, stderrTask]);
-  return { code, parsed, stderr };
-}
-
 function normalizeCategory(category) {
   if (typeof category !== "string") return null;
   const trimmed = category.trim();
@@ -289,6 +161,7 @@ export class ToolRegistry {
       policy: executionPolicy,
       logger
     });
+    this.concurrentExecutions = new Map();
   }
 
   async buildSnapshot() {
@@ -393,29 +266,44 @@ export class ToolRegistry {
   async help(name) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
-    const result = await runProcess("node", [tool.entry, "--help"], {
-      cwd: tool.dir,
-      env: toolEnv(),
-      timeoutMs: this.helpTimeoutMs,
-      killGraceMs: this.killGraceMs,
-      label: `Tool help for ${name}`
-    });
-    const help = result.stdout || result.stderr;
-    const skills = await this.resolveSkills(name);
-    const sections = [
-      help.trimEnd(),
-      formatSemanticMetadata(tool),
-      formatToolDependencies(tool, this.tools)
-    ];
-    if (skills.length) {
-      const skillHelp = skills.map((item) => [
-        `- ${item.name}${item.when ? ` (${item.when})` : ""}`,
-        item.description ? `  ${item.description}` : null,
-        item.found ? `  path: ${item.path}` : "  warning: skill not found"
-      ].filter(Boolean).join("\n")).join("\n");
-      sections.push(`Assigned skills:\n${skillHelp}`);
+    const lease = await this.executionGovernor.acquire(tool.execution, `${name}:help`);
+    try {
+      const execution = executionForLease(tool.execution, lease);
+      const nodeArgs = [
+        ...(execution?.maxHeapMb ? [`--max-old-space-size=${execution.maxHeapMb}`] : []),
+        tool.entry,
+        "--help"
+      ];
+      const invocation = isolatedToolProcessInvocation(nodeArgs, execution);
+      const result = await runToolHelpProcess(invocation.command, invocation.args, {
+        cwd: tool.dir,
+        env: toolProcessEnv(),
+        timeoutMs: this.helpTimeoutMs,
+        killGraceMs: this.killGraceMs,
+        maxOutputBytes: execution?.maxOutputBytes || daemonConfigDefaults.ipcFrameBytes,
+        label: `Tool help for ${name}`
+      });
+      const help = result.stdout || result.stderr;
+      const skills = await this.resolveSkills(name);
+      const sections = [
+        help.trimEnd(),
+        formatSemanticMetadata(tool),
+        formatToolDependencies(tool, this.tools)
+      ];
+      if (skills.length) {
+        const skillHelp = skills.map((item) => [
+          `- ${item.name}${item.when ? ` (${item.when})` : ""}`,
+          item.description ? `  ${item.description}` : null,
+          item.found ? `  path: ${item.path}` : "  warning: skill not found"
+        ].filter(Boolean).join("\n")).join("\n");
+        sections.push(`Assigned skills:\n${skillHelp}`);
+      }
+      lease.release({ success: result.code === 0 });
+      return `${sections.filter(Boolean).join("\n\n")}\n`;
+    } catch (error) {
+      lease.release({ memoryLimited: error?.code === "TOOL_PROCESS_MEMORY_LIMIT" });
+      throw error;
     }
-    return `${sections.filter(Boolean).join("\n\n")}\n`;
   }
 
   async resolveSkills(name) {
@@ -476,7 +364,25 @@ export class ToolRegistry {
       .sort((left, right) => left.name.localeCompare(right.name));
   }
 
-  async run({ name, request, chatId = null, onEvent = null }) {
+  async run(invocation) {
+    const tool = this.get(invocation.name);
+    if (!tool?.execution?.deduplicateConcurrent) return this.runOnce(invocation);
+    const key = concurrentExecutionKey(invocation.name, invocation.chatId, invocation.request);
+    const active = this.concurrentExecutions.get(key);
+    if (active) {
+      this.logger?.log("tools", `joined concurrent duplicate ${invocation.name}`);
+      return active;
+    }
+    const execution = this.runOnce(invocation);
+    this.concurrentExecutions.set(key, execution);
+    try {
+      return await execution;
+    } finally {
+      if (this.concurrentExecutions.get(key) === execution) this.concurrentExecutions.delete(key);
+    }
+  }
+
+  async runOnce({ name, request, chatId = null, onEvent = null }) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
     const dependencyIssue = this.dependencyIssues(name)[0];
@@ -490,6 +396,7 @@ export class ToolRegistry {
     const tmpDir = chatId != null ? getChatToolTmpDir(chatId, name) : getToolTmpDir(name);
     const requestFile = path.join(tmpDir, `.request-${Date.now()}-${randomUUID()}.json`);
     let lease = null;
+    let leaseOutcome = {};
     let result;
     try {
       lease = await this.executionGovernor.acquire(tool.execution, name);
@@ -511,11 +418,25 @@ export class ToolRegistry {
         result = await runtime.submit(enrichedRequest, { onEvent });
       } else {
         await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
-        const processResult = await runToolProcess("node", [tool.entry, "run", "--request-file", requestFile], {
+        const execution = executionForLease(tool.execution, lease);
+        const nodeArgs = [
+          ...(execution?.maxHeapMb ? [`--max-old-space-size=${execution.maxHeapMb}`] : []),
+          tool.entry,
+          "run",
+          "--request-file",
+          requestFile
+        ];
+        const processInvocation = isolatedToolProcessInvocation(nodeArgs, execution);
+        if (processInvocation.isolated) {
+          this.logger?.log("tools", `${name} isolated at ${execution.maxMemoryMb} MiB total memory (${execution.maxHeapMb} MiB heap)`);
+        }
+        const processResult = await runToolProcess(processInvocation.command, processInvocation.args, {
           cwd: tool.dir,
-          env: toolEnv(),
+          env: toolProcessEnv(),
           onEvent,
+          parserName: name,
           maxFrameBytes: daemonConfigDefaults.ipcFrameBytes,
+          maxOutputBytes: tool.execution?.maxOutputBytes || daemonConfigDefaults.ipcFrameBytes,
           timeoutMs: this.runTimeoutMs,
           killGraceMs: this.killGraceMs,
           label: `Tool run for ${name}`
@@ -523,11 +444,21 @@ export class ToolRegistry {
         if (processResult.stderr.trim()) {
           this.logger?.log("tools", `${name} stderr: ${processResult.stderr.trim()}`);
         }
+        if (processResult.code !== 0) {
+          const memoryLimited = /heap limit|heap out of memory|allocation failed.*memory|memory cgroup out of memory|\bkilled\b/i.test(processResult.stderr)
+            || (processInvocation.isolated && [9, 134, 137].includes(processResult.code));
+          const error = new Error(memoryLimited
+            ? `Tool ${name} exceeded its isolated memory limit`
+            : `Tool ${name} exited with code ${processResult.code}`);
+          error.code = memoryLimited ? "TOOL_PROCESS_MEMORY_LIMIT" : "TOOL_PROCESS_EXIT";
+          throw error;
+        }
         result = processResult.parsed.mode === "ndjson"
           ? processResult.parsed.result
           : JSON.parse(processResult.parsed.output);
       }
       const normalized = normalizeToolResult(name, result);
+      leaseOutcome = { success: normalized.ok !== false };
       if (normalized.ok === false) {
         this.logger?.log("tools", `${name} -> ${normalized.status || "error"}: ${normalized.error || "unknown error"}`);
       } else {
@@ -535,7 +466,20 @@ export class ToolRegistry {
       }
       return normalized;
     } catch (error) {
-      if (error?.code === "TOOL_PROCESS_TIMEOUT") {
+      leaseOutcome = { memoryLimited: error?.code === "TOOL_PROCESS_MEMORY_LIMIT" };
+      if (error?.code === "TOOL_RESOURCE_PRESSURE") {
+        return normalizeToolResult(name, {
+          ok: false,
+          status: "retryable",
+          error: error.message,
+          resolution: {
+            type: "retry_later",
+            retry: true,
+            message: "The tool was not started. Retry after host memory pressure falls."
+          }
+        });
+      }
+      if (["TOOL_PROCESS_TIMEOUT", "TOOL_OUTPUT_LIMIT", "TOOL_PROCESS_MEMORY_LIMIT", "TOOL_PROCESS_EXIT"].includes(error?.code)) {
         return normalizeToolResult(name, {
           ok: false,
           status: "outcome_uncertain",
@@ -543,7 +487,7 @@ export class ToolRegistry {
           resolution: {
             type: "status_check_required",
             retry: false,
-            message: "The tool process was terminated after timing out. Check external state before retrying."
+            message: "The isolated tool process ended without a confirmed result. Check external state before retrying."
           }
         });
       }
@@ -552,7 +496,7 @@ export class ToolRegistry {
         error: error?.message || `Invalid tool response for ${name}`
       });
     } finally {
-      lease?.release();
+      lease?.release(leaseOutcome);
       await unlink(requestFile).catch(() => {});
       await rmdir(tmpDir).catch(() => {});
       if (chatId != null) {

package/src/core/tools/tool-resource-note-store.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { getChatToolResourceNotesFile } from "../../runtime/paths.js";
+import { getChatToolResourceNotesFile } from "../../platform/paths.js";
 
 export const maxToolResourceNoteCharacters = 200;
 

package/src/core/tools/tool-usage-store.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { getChatToolUsageFile } from "../../runtime/paths.js";
+import { getChatToolUsageFile } from "../../platform/paths.js";
 
 function emptyUsage() {
   return { version: 1, tools: {} };