@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/agent/agent-stuck-detector.ts

@@ -0,0 +1,288 @@
+import fs = require('fs');
+
+interface SafeExecModule {
+  execSync(command: string, options: { encoding: 'utf8'; timeout: number }): string;
+}
+
+interface MissingProcessState {
+  exists: false;
+  error?: unknown;
+}
+
+interface PresentProcessState {
+  exists: true;
+  state: string | undefined;
+  wchan: string;
+  cpuTicks: number;
+  threads: number;
+  volCtxSwitches: number;
+}
+
+type ProcessState = MissingProcessState | PresentProcessState;
+
+interface ConnectionState {
+  state: string;
+  recvQ: number;
+  sendQ: number;
+  local: string;
+  peer: string;
+}
+
+interface NetworkState {
+  hasNetwork: boolean;
+  connections?: ConnectionState[];
+  establishedCount?: number;
+  hasDataInFlight?: boolean;
+  hasSynSent?: boolean;
+  error?: unknown;
+}
+
+interface HealthIndicators {
+  isSleeping: boolean;
+  isBlockedOnPoll: boolean;
+  lowCpuUsage: boolean;
+  lowCtxSwitches: boolean;
+  noDataInFlight: boolean;
+  hasSynSent: boolean | undefined;
+}
+
+interface AvailableProcessHealth {
+  pid: number;
+  state: string | undefined;
+  wchan: string;
+  cpuPercent: number;
+  ctxSwitchesDelta: number;
+  threads: number;
+  network: {
+    hasConnections: boolean;
+    establishedCount: number;
+    hasDataInFlight: boolean;
+    hasSynSent: boolean;
+  };
+  indicators: HealthIndicators;
+  stuckScore: number;
+  isLikelyStuck: boolean;
+  confidence: 'low' | 'medium' | 'high';
+  analysis: string;
+}
+
+interface UnavailableProcessHealth {
+  isLikelyStuck: null;
+  reason: string;
+  pid: number;
+}
+
+type ProcessHealth = AvailableProcessHealth | UnavailableProcessHealth;
+
+type SocketFields = [string, string, string, string, string];
+
+function isSafeExecModule(value: unknown): value is SafeExecModule {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'execSync' in value &&
+    typeof value.execSync === 'function'
+  );
+}
+
+function errorMessage(error: unknown): unknown {
+  if (typeof error === 'object' && error !== null && 'message' in error) {
+    return error.message;
+  }
+  return undefined;
+}
+
+function parseProcInteger(value: string | undefined): number {
+  return value === undefined ? Number.NaN : parseInt(value, 10);
+}
+
+function hasSocketFields(fields: string[] | undefined): fields is SocketFields {
+  return fields?.length === 5;
+}
+
+const STUCK_THRESHOLD = 3.5;
+const HIGH_CONFIDENCE_THRESHOLD = 4.5;
+const CPU_LOW_THRESHOLD = 1;
+const CTX_SWITCHES_LOW_THRESHOLD = 10;
+
+function stuckScoreFor(indicators: HealthIndicators, hasDataInFlight: boolean | undefined): number {
+  const score =
+    Number(indicators.isSleeping) +
+    Number(indicators.isBlockedOnPoll) +
+    Number(indicators.lowCpuUsage) +
+    Number(indicators.lowCtxSwitches) +
+    Number(indicators.noDataInFlight) * 0.5 +
+    Number(Boolean(indicators.hasSynSent));
+  return hasDataInFlight ? Math.max(0, score - 2) : score;
+}
+
+function confidenceFor(stuckScore: number): AvailableProcessHealth['confidence'] {
+  if (stuckScore >= HIGH_CONFIDENCE_THRESHOLD) return 'high';
+  if (stuckScore >= STUCK_THRESHOLD) return 'medium';
+  return 'low';
+}
+
+const rawSafeExec: unknown = require('../lib/safe-exec');
+if (!isSafeExecModule(rawSafeExec)) {
+  throw new TypeError('safe-exec must export execSync');
+}
+const { execSync } = rawSafeExec;
+
+function getProcessState(pid: number): ProcessState {
+  try {
+    const statPath = `/proc/${pid}/stat`;
+    if (!fs.existsSync(statPath)) {
+      return { exists: false };
+    }
+
+    const stat = fs.readFileSync(statPath, 'utf8');
+    const parts = stat.split(' ');
+    const state = parts[2];
+
+    let wchan = '';
+    try {
+      wchan = fs.readFileSync(`/proc/${pid}/wchan`, 'utf8').trim();
+    } catch {
+      // wchan may not be readable.
+    }
+
+    const utime = parseProcInteger(parts[13]);
+    const stime = parseProcInteger(parts[14]);
+    const status = fs.readFileSync(`/proc/${pid}/status`, 'utf8');
+    const threads = /Threads:\s+(\d+)/.exec(status)?.[1] || '1';
+    const volCtxSwitches = /voluntary_ctxt_switches:\s+(\d+)/.exec(status)?.[1] || '0';
+
+    return {
+      exists: true,
+      state,
+      wchan,
+      cpuTicks: utime + stime,
+      threads: parseInt(threads, 10),
+      volCtxSwitches: parseInt(volCtxSwitches, 10),
+    };
+  } catch (error: unknown) {
+    return { exists: false, error: errorMessage(error) };
+  }
+}
+
+function getNetworkState(pid: number): NetworkState {
+  try {
+    const fdPath = `/proc/${pid}/fd`;
+    if (!fs.existsSync(fdPath)) {
+      return { hasNetwork: false };
+    }
+
+    let ssOutput = '';
+    try {
+      ssOutput = execSync(`ss -tunp 2>/dev/null | grep ",pid=${pid}," || true`, {
+        encoding: 'utf8',
+        timeout: 5000,
+      });
+    } catch {
+      return { hasNetwork: false };
+    }
+
+    if (!ssOutput.trim()) {
+      return { hasNetwork: false, connections: [] };
+    }
+
+    const connections: ConnectionState[] = [];
+    for (const line of ssOutput.trim().split('\n')) {
+      const match = /^(\S+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S+)/.exec(line);
+      const fields = match?.slice(1, 6);
+      if (!hasSocketFields(fields)) continue;
+      const [state, recvQ, sendQ, local, peer] = fields;
+      connections.push({
+        state,
+        recvQ: parseInt(recvQ, 10),
+        sendQ: parseInt(sendQ, 10),
+        local,
+        peer,
+      });
+    }
+
+    return {
+      hasNetwork: connections.length > 0,
+      connections,
+      establishedCount: connections.filter((connection) => connection.state === 'ESTAB').length,
+      hasDataInFlight: connections.some(
+        (connection) => connection.recvQ > 0 || connection.sendQ > 0
+      ),
+      hasSynSent: connections.some((connection) => connection.state === 'SYN-SENT'),
+    };
+  } catch (error: unknown) {
+    return { hasNetwork: false, error: errorMessage(error) };
+  }
+}
+
+async function analyzeProcessHealth(pid: number, samplePeriodMs = 5000): Promise<ProcessHealth> {
+  const t0 = getProcessState(pid);
+  if (!t0.exists) {
+    return { isLikelyStuck: null, reason: 'Process does not exist', pid };
+  }
+
+  await new Promise<void>((resolve) => setTimeout(resolve, samplePeriodMs));
+
+  const t1 = getProcessState(pid);
+  if (!t1.exists) {
+    return { isLikelyStuck: null, reason: 'Process died during analysis', pid };
+  }
+
+  const cpuTicksDelta = t1.cpuTicks - t0.cpuTicks;
+  const ctxSwitchesDelta = t1.volCtxSwitches - t0.volCtxSwitches;
+  const cpuSeconds = cpuTicksDelta / 100;
+  const sampleSeconds = samplePeriodMs / 1000;
+  const cpuPercent = (cpuSeconds / sampleSeconds) * 100;
+  const network = getNetworkState(pid);
+
+  const indicators = {
+    isSleeping: t1.state === 'S',
+    isBlockedOnPoll: t1.wchan.includes('poll') || t1.wchan.includes('wait'),
+    lowCpuUsage: cpuPercent < CPU_LOW_THRESHOLD,
+    lowCtxSwitches: ctxSwitchesDelta < CTX_SWITCHES_LOW_THRESHOLD,
+    noDataInFlight: network.hasNetwork && !network.hasDataInFlight,
+    hasSynSent: network.hasSynSent,
+  };
+
+  const stuckScore = stuckScoreFor(indicators, network.hasDataInFlight);
+  const isLikelyStuck = stuckScore >= STUCK_THRESHOLD;
+  const confidence = confidenceFor(stuckScore);
+
+  return {
+    pid,
+    state: t1.state,
+    wchan: t1.wchan,
+    cpuPercent: parseFloat(cpuPercent.toFixed(2)),
+    ctxSwitchesDelta,
+    threads: t1.threads,
+    network: {
+      hasConnections: network.hasNetwork,
+      establishedCount: network.establishedCount || 0,
+      hasDataInFlight: network.hasDataInFlight || false,
+      hasSynSent: network.hasSynSent || false,
+    },
+    indicators,
+    stuckScore: parseFloat(stuckScore.toFixed(1)),
+    isLikelyStuck,
+    confidence,
+    analysis: isLikelyStuck
+      ? `Process appears STUCK: sleeping on ${t1.wchan}, ${cpuPercent.toFixed(1)}% CPU, ` +
+        `${ctxSwitchesDelta} ctx switches`
+      : `Process appears WORKING: ${cpuPercent.toFixed(1)}% CPU, ${ctxSwitchesDelta} ctx switches, state=${t1.state}`,
+  };
+}
+
+function isPlatformSupported(): boolean {
+  return process.platform === 'linux' && fs.existsSync('/proc');
+}
+
+export = {
+  analyzeProcessHealth,
+  getProcessState,
+  getNetworkState,
+  isPlatformSupported,
+  STUCK_THRESHOLD,
+  HIGH_CONFIDENCE_THRESHOLD,
+  CPU_LOW_THRESHOLD,
+  CTX_SWITCHES_LOW_THRESHOLD,
+};

package/src/agent/agent-trigger-evaluator.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * AgentTriggerEvaluator - Trigger matching and logic evaluation
  *
@@ -6,62 +7,44 @@
  * - Logic evaluation via LogicEngine
  * - Trigger action determination
  */
-
 /**
- * Find trigger matching the message topic
- * @param {Object} params - Evaluation parameters
- * @param {Array} params.triggers - Agent triggers configuration
- * @param {Object} params.message - Message to match against
- * @returns {Object|null} Matching trigger or null
+ * Find trigger matching the message topic.
  */
-function findMatchingTrigger({ triggers, message }) {
-  if (!triggers) {
-    return null;
-  }
-
-  return triggers.find((trigger) => {
-    // Match exact topic or wildcard
-    if (trigger.topic === '*' || trigger.topic === message.topic) {
-      return true;
+function findMatchingTrigger({ triggers, message, }) {
+    if (!triggers) {
+        return null;
     }
-    // Match topic prefix (e.g., "VALIDATION_*")
-    if (trigger.topic.endsWith('*')) {
-      const prefix = trigger.topic.slice(0, -1);
-      return message.topic.startsWith(prefix);
-    }
-    return false;
-  });
+    return triggers.find((trigger) => {
+        // Match exact topic or wildcard
+        if (trigger.topic === '*' || trigger.topic === message.topic) {
+            return true;
+        }
+        // Match topic prefix (e.g., "VALIDATION_*")
+        if (trigger.topic.endsWith('*')) {
+            const prefix = trigger.topic.slice(0, -1);
+            return message.topic.startsWith(prefix);
+        }
+        return false;
+    });
 }
-
 /**
- * Evaluate trigger logic
- * @param {Object} params - Evaluation parameters
- * @param {Object} params.trigger - Trigger to evaluate
- * @param {Object} params.message - Triggering message
- * @param {Object} params.agent - Agent context (id, role, iteration, cluster_id)
- * @param {Object} params.logicEngine - LogicEngine instance
- * @returns {boolean} Whether trigger logic passed
+ * Evaluate trigger logic.
  */
-function evaluateTrigger({ trigger, message, agent, logicEngine }) {
-  if (!trigger.logic || !trigger.logic.script) {
-    return true; // No logic = always true
-  }
-
-  // NO TRY/CATCH - let errors propagate and crash
-  return logicEngine.evaluate(trigger.logic.script, agent, message);
+function evaluateTrigger({ trigger, message, agent, logicEngine, }) {
+    if (!trigger.logic || !trigger.logic.script) {
+        return true; // No logic = always true
+    }
+    // NO TRY/CATCH - let errors propagate and crash
+    return logicEngine.evaluate(trigger.logic.script, agent, message);
 }
-
 /**
- * Get trigger action type
- * @param {Object} trigger - Trigger object
- * @returns {string} Action type ('execute_task' or 'stop_cluster')
+ * Get trigger action type.
  */
 function getTriggerAction(trigger) {
-  return trigger.action || 'execute_task';
+    return trigger.action || 'execute_task';
 }
-
 module.exports = {
-  findMatchingTrigger,
-  evaluateTrigger,
-  getTriggerAction,
+    findMatchingTrigger,
+    evaluateTrigger,
+    getTriggerAction,
 };

package/src/agent/agent-trigger-evaluator.ts

@@ -0,0 +1,98 @@
+/**
+ * AgentTriggerEvaluator - Trigger matching and logic evaluation
+ *
+ * Provides:
+ * - Trigger matching based on message topics
+ * - Logic evaluation via LogicEngine
+ * - Trigger action determination
+ */
+
+interface TriggerLogic {
+  script?: string;
+}
+
+interface AgentTrigger {
+  topic: string;
+  logic?: TriggerLogic;
+  action?: string;
+}
+
+interface TriggerMessage {
+  topic: string;
+  [key: string]: unknown;
+}
+
+interface AgentContext {
+  [key: string]: unknown;
+}
+
+interface LogicEngine {
+  evaluate(script: string, agent: AgentContext, message: TriggerMessage): boolean;
+}
+
+interface MatchingTriggerOptions {
+  triggers?: readonly AgentTrigger[] | null;
+  message: TriggerMessage;
+}
+
+interface EvaluateTriggerOptions {
+  trigger: AgentTrigger;
+  message: TriggerMessage;
+  agent: AgentContext;
+  logicEngine: LogicEngine;
+}
+
+/**
+ * Find trigger matching the message topic.
+ */
+function findMatchingTrigger({
+  triggers,
+  message,
+}: MatchingTriggerOptions): AgentTrigger | null | undefined {
+  if (!triggers) {
+    return null;
+  }
+
+  return triggers.find((trigger) => {
+    // Match exact topic or wildcard
+    if (trigger.topic === '*' || trigger.topic === message.topic) {
+      return true;
+    }
+    // Match topic prefix (e.g., "VALIDATION_*")
+    if (trigger.topic.endsWith('*')) {
+      const prefix = trigger.topic.slice(0, -1);
+      return message.topic.startsWith(prefix);
+    }
+    return false;
+  });
+}
+
+/**
+ * Evaluate trigger logic.
+ */
+function evaluateTrigger({
+  trigger,
+  message,
+  agent,
+  logicEngine,
+}: EvaluateTriggerOptions): boolean {
+  if (!trigger.logic || !trigger.logic.script) {
+    return true; // No logic = always true
+  }
+
+  // NO TRY/CATCH - let errors propagate and crash
+  return logicEngine.evaluate(trigger.logic.script, agent, message);
+}
+
+/**
+ * Get trigger action type.
+ */
+function getTriggerAction(trigger: AgentTrigger): string {
+  return trigger.action || 'execute_task';
+}
+
+export = {
+  findMatchingTrigger,
+  evaluateTrigger,
+  getTriggerAction,
+};