@ai-setting/roy-agent-core 1.6.17 → 1.6.18

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

@@ -648,6 +648,128 @@ function buildErrorReturn(args) {
     }
   };
 }
+var MAX_ERROR_MESSAGE_CHARS = 1500;
+var ERROR_CLASSIFICATION_PREFIX = "[ErrorType=";
+function classifyError(error) {
+  if (error instanceof Error) {
+    const rawName = typeof error.name === "string" && error.name.trim() ? error.name.trim() : "Error";
+    const safeName = rawName.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80);
+    if (!error.message)
+      return `${ERROR_CLASSIFICATION_PREFIX}${safeName}:EmptyMessage]`;
+    return `${ERROR_CLASSIFICATION_PREFIX}${safeName}]`;
+  }
+  if (error === null)
+    return `${ERROR_CLASSIFICATION_PREFIX}Null]`;
+  if (error === undefined)
+    return `${ERROR_CLASSIFICATION_PREFIX}Undefined]`;
+  if (typeof error === "string") {
+    if (error.trim().length === 0)
+      return `${ERROR_CLASSIFICATION_PREFIX}EmptyString]`;
+    return `${ERROR_CLASSIFICATION_PREFIX}String]`;
+  }
+  if (typeof error === "number")
+    return `${ERROR_CLASSIFICATION_PREFIX}Number]`;
+  if (typeof error === "boolean")
+    return `${ERROR_CLASSIFICATION_PREFIX}Boolean]`;
+  if (typeof error === "object")
+    return `${ERROR_CLASSIFICATION_PREFIX}Object]`;
+  return `${ERROR_CLASSIFICATION_PREFIX}Unknown]`;
+}
+function normalizeErrorMessage(error) {
+  if (error instanceof Error) {
+    if (typeof error.message === "string" && error.message.length > 0) {
+      return error.message;
+    }
+    return error.name && error.name !== "Error" ? error.name : "";
+  }
+  if (typeof error === "string")
+    return error;
+  if (typeof error === "number" || typeof error === "boolean") {
+    return String(error);
+  }
+  return "";
+}
+function sanitizeErrorMessage(message, sensitive) {
+  if (!message || sensitive.length === 0)
+    return message;
+  let sanitized = message;
+  const ordered = [...sensitive].sort((a, b) => b.length - a.length);
+  for (const secret of ordered) {
+    if (!secret)
+      continue;
+    sanitized = sanitized.split(secret).join("[REDACTED]");
+  }
+  return sanitized;
+}
+function capErrorLength(message, max = MAX_ERROR_MESSAGE_CHARS) {
+  if (typeof message !== "string" || message.length <= max)
+    return message;
+  const truncated = message.substring(0, max);
+  return `${truncated}…[truncated ${message.length - max} chars; original=${message.length}]`;
+}
+function errorMessageBaseFor(message) {
+  return typeof message === "string" && message.length > 0 ? message : "";
+}
+function collectSensitiveValues(input, messageForEnvScan) {
+  const sensitive = [];
+  if (input && typeof input === "object") {
+    for (const v of Object.values(input)) {
+      if (typeof v === "string" && v.length >= 6)
+        sensitive.push(v);
+    }
+  }
+  const envSecretKeys = new Set;
+  try {
+    for (const [k, v] of Object.entries(process.env ?? {})) {
+      if (typeof v !== "string" || v.length < 6)
+        continue;
+      const kLower = k.toLowerCase();
+      if (kLower.includes("token") || kLower.includes("secret") || kLower.includes("password") || kLower.includes("api_key") || kLower.includes("apikey")) {
+        sensitive.push(v);
+        envSecretKeys.add(k);
+      }
+    }
+  } catch {}
+  if (messageForEnvScan) {
+    try {
+      for (const [k, v] of Object.entries(process.env ?? {})) {
+        if (typeof v !== "string" || v.length < 8)
+          continue;
+        if (envSecretKeys.has(k))
+          continue;
+        if (messageForEnvScan.includes(v) && (/[0-9_-]/.test(v) || /^[A-Za-z0-9+/=_-]+$/.test(v))) {
+          sensitive.push(v);
+        }
+      }
+    } catch {}
+  }
+  return sensitive;
+}
+function extractStackSummary(message) {
+  if (typeof message !== "string" || message.length === 0)
+    return "";
+  const lines = message.split(/\r?\n/).map((l) => l.trimEnd()).filter((l) => l.length > 0);
+  if (lines.length === 0)
+    return "";
+  const picked = [lines[0]];
+  let frameCount = 0;
+  for (let i = 1;i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*(File\s+|at\s+)/.test(line)) {
+      picked.push(line);
+      frameCount++;
+      if (frameCount >= 3)
+        break;
+    }
+  }
+  const lastLine = lines[lines.length - 1];
+  if (picked[picked.length - 1] !== lastLine && !/^\s*(File\s+|at\s+)/.test(lastLine)) {
+    picked.push(lastLine);
+  }
+  const joined = picked.join(`
+`);
+  return joined.length > 600 ? joined.slice(0, 600) + "…[truncated]" : joined;
+}
 var RunWorkflowInputSchema = z8.object({
   workflow_name: z8.string().describe("Name of the workflow to run"),
   input: z8.record(z8.any()).optional().describe("Input to pass to the workflow"),
@@ -801,11 +923,42 @@ function createRunWorkflowTool(workflowService, hooks) {
         }
         durationMs = Date.now() - startTime;
         const finalRunId = capturedByCallback ? capturedRunId : result.runId ?? "";
+        const resolvedStatus = result.status;
+        const isResolvedFailure = resolvedStatus === "failed" || resolvedStatus === "stopped";
+        const sensitiveForResolved = collectSensitiveValues(input, errorMessageBaseFor(result.error ?? ""));
+        const sanitizedResolvedMessage = sanitizeErrorMessage(errorMessageBaseFor(result.error ?? ""), sensitiveForResolved);
+        const resolvedErrorClassification = result.error ? classifyError(new Error(result.error)) : "[ErrorType=EmptyMessage]";
+        const resolvedErrorMessage = capErrorLength(sanitizedResolvedMessage.length > 0 ? sanitizedResolvedMessage : "Workflow reported status=failed without an error message (runId=" + finalRunId + ")");
+        if (isResolvedFailure) {
+          const failureCode = result.error ? "WORKFLOW_FAILED" : "WORKFLOW_FAILED_NO_MESSAGE";
+          return {
+            success: false,
+            output: {
+              run_id: finalRunId,
+              session_id: result.sessionId ?? finalRunId,
+              status: resolvedStatus,
+              error: result.error,
+              error_code: failureCode,
+              error_message: result.error ? sanitizedResolvedMessage : "",
+              error_stack_summary: extractStackSummary(result.error ?? ""),
+              output: result.output,
+              duration_ms: result.durationMs || durationMs,
+              ...result.pendingNodeId ? { pending_node_id: result.pendingNodeId } : {},
+              ...result.query ? { query: result.query } : {},
+              ...result.agentSessionId ? { agent_session_id: result.agentSessionId } : {}
+            },
+            error: `${resolvedErrorMessage} ${resolvedErrorClassification} (runId: ${finalRunId})`,
+            metadata: {
+              execution_time_ms: durationMs,
+              run_id: finalRunId
+            }
+          };
+        }
         return {
-          success: result.status === "completed" || result.status === "paused",
+          success: resolvedStatus === "completed" || resolvedStatus === "paused",
           output: {
             run_id: finalRunId,
-            status: result.status,
+            status: resolvedStatus,
             output: result.output,
             error: result.error,
             duration_ms: result.durationMs || durationMs,
@@ -823,9 +976,13 @@ function createRunWorkflowTool(workflowService, hooks) {
           clearTimeout(timeoutHandle);
         }
         durationMs = Date.now() - startTime;
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorClassification = classifyError(error);
+        const rawErrorMessage = normalizeErrorMessage(error);
+        const errorMessageBase = rawErrorMessage.length > 0 ? rawErrorMessage : `${errorClassification} (no message from thrown value)`;
         const errorRunId = capturedRunId ?? reservedRunId;
-        if (errorMessage.includes("Workflow not found")) {
+        const sensitiveValues = collectSensitiveValues(input, errorMessageBase);
+        const sanitizedMessage = sanitizeErrorMessage(errorMessageBase, sensitiveValues);
+        if (sanitizedMessage.includes("Workflow not found")) {
           return buildErrorReturn({
             errorRunId,
             status: "failed",
@@ -833,7 +990,7 @@ function createRunWorkflowTool(workflowService, hooks) {
             durationMs
           });
         }
-        const isTimeoutLike = errorMessage.includes("abort") || errorMessage.includes("timed out") || errorMessage.includes("execution timeout:");
+        const isTimeoutLike = sanitizedMessage.includes("abort") || sanitizedMessage.includes("timed out") || sanitizedMessage.includes("execution timeout:");
         if (isTimeoutLike) {
           if (!timedOut) {
             attemptStopOnTimeout(workflowService, errorRunId, "timed out");
@@ -846,12 +1003,16 @@ function createRunWorkflowTool(workflowService, hooks) {
           });
         }
         if (logger7?.error) {
-          logger7.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
+          logger7.error(`Failed to run workflow: ${workflow_name}`, {
+            error: rawErrorMessage,
+            errorClassification
+          });
         }
+        const composed = rawErrorMessage.length > 0 ? `Failed to run workflow ${workflow_name}: ${sanitizedMessage} ${errorClassification}` : `Failed to run workflow ${workflow_name} ${errorClassification}: ${sanitizedMessage}`;
         return buildErrorReturn({
           errorRunId,
           status: "failed",
-          errorMessage: `Failed to run workflow ${workflow_name}: ${errorMessage}`,
+          errorMessage: capErrorLength(composed),
           durationMs
         });
       }

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

@@ -8,7 +8,7 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-4cgkj7v0.js";
+} from "./roy-agent-core-n1fx2fx4.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
@@ -24,7 +24,7 @@ import {
   searchTasksTool,
   treeTasksTool,
   updateTaskTool
-} from "./roy-agent-core-r0t34bbh.js";
+} from "./roy-agent-core-c7e3htaq.js";
 import {
   createOperationTool,
   deleteOperationTool,