@the-open-engine/zeroshot 6.38.1 → 6.39.1

package/src/agent/agent-liveness-poll.js

@@ -1,93 +1,89 @@
-const { isPlatformSupported } = require('./agent-stuck-detector');
-
+"use strict";
+function isAgentStuckDetectorModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'isPlatformSupported' in value &&
+        typeof value.isPlatformSupported === 'function');
+}
+const agentStuckDetectorModule = require('./agent-stuck-detector');
+if (!isAgentStuckDetectorModule(agentStuckDetectorModule)) {
+    throw new TypeError('agent-stuck-detector must export isPlatformSupported');
+}
+const isPlatformSupported = agentStuckDetectorModule.isPlatformSupported;
 function hasRecoverableTask(agent) {
-  return (
-    Boolean(agent.currentTask) ||
-    Boolean(agent.isolation?.enabled && agent.currentTaskId) ||
-    agent.nestedExecutions?.hasActive === true
-  );
+    return (Boolean(agent.currentTask) ||
+        Boolean(agent.isolation?.enabled && agent.currentTaskId) ||
+        agent.nestedExecutions?.hasActive === true);
 }
-
 function handlePendingTermination(agent, settings, now, attemptTermination) {
-  if (!agent.livenessTerminationContext) return false;
-  if (now >= agent.livenessTerminationRetryAt) attemptTermination(agent, settings);
-  return true;
+    if (!agent.livenessTerminationContext)
+        return false;
+    if (now >= agent.livenessTerminationRetryAt)
+        attemptTermination(agent, settings);
+    return true;
 }
-
 function taskTiming(agent, now) {
-  const taskStartedAt = agent.taskStartedAt || agent.lastOutputTime || now;
-  const lastOutputTime = agent.lastOutputTime || taskStartedAt;
-  return {
-    taskRuntime: now - taskStartedAt,
-    timeSinceLastOutput: now - lastOutputTime,
-    lastOutputTime,
-  };
+    const taskStartedAt = agent.taskStartedAt || agent.lastOutputTime || now;
+    const lastOutputTime = agent.lastOutputTime || taskStartedAt;
+    return {
+        taskRuntime: now - taskStartedAt,
+        timeSinceLastOutput: now - lastOutputTime,
+        lastOutputTime,
+    };
 }
-
 function handleTaskTimeout(context, timing) {
-  const { agent, settings, configuredTimeout, beginTermination } = context;
-  if (!configuredTimeout || timing.taskRuntime < configuredTimeout) return false;
-  beginTermination(
-    agent,
-    settings,
-    `Task timed out after ${configuredTimeout}ms`,
-    'AGENT_TASK_TIMEOUT',
-    {
-      taskId: agent.currentTaskId,
-      taskRuntime: timing.taskRuntime,
-      timeout: configuredTimeout,
-    }
-  );
-  return true;
+    const { agent, settings, configuredTimeout, beginTermination } = context;
+    if (!configuredTimeout || timing.taskRuntime < configuredTimeout)
+        return false;
+    beginTermination(agent, settings, `Task timed out after ${configuredTimeout}ms`, 'AGENT_TASK_TIMEOUT', {
+        taskId: agent.currentTaskId,
+        taskRuntime: timing.taskRuntime,
+        timeout: configuredTimeout,
+    });
+    return true;
 }
-
 function publishStaleWarning(context, timing) {
-  const { agent, staleDuration, warningsBeforeKill } = context;
-  agent.consecutiveStaleWarnings += 1;
-  agent._publishLifecycle('AGENT_STALE_WARNING', {
-    taskId: agent.currentTaskId,
-    timeSinceLastOutput: timing.timeSinceLastOutput,
-    staleDuration,
-    lastOutputTime: timing.lastOutputTime,
-    consecutiveWarnings: agent.consecutiveStaleWarnings,
-    warningsBeforeKill,
-    processDiagnosticsAvailable: isPlatformSupported(),
-    analysis: `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
-  });
+    const { agent, staleDuration, warningsBeforeKill } = context;
+    agent.consecutiveStaleWarnings += 1;
+    agent._publishLifecycle('AGENT_STALE_WARNING', {
+        taskId: agent.currentTaskId,
+        timeSinceLastOutput: timing.timeSinceLastOutput,
+        staleDuration,
+        lastOutputTime: timing.lastOutputTime,
+        consecutiveWarnings: agent.consecutiveStaleWarnings,
+        warningsBeforeKill,
+        processDiagnosticsAvailable: isPlatformSupported(),
+        analysis: `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
+    });
 }
-
 function terminateForInactivity(context, timing) {
-  const { agent, settings, staleDuration, beginTermination } = context;
-  beginTermination(
-    agent,
-    settings,
-    `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
-    'PROVIDER_INACTIVITY_TIMEOUT',
-    {
-      taskId: agent.currentTaskId,
-      timeSinceLastOutput: timing.timeSinceLastOutput,
-      staleDuration,
-      consecutiveWarnings: agent.consecutiveStaleWarnings,
-    }
-  );
+    const { agent, settings, staleDuration, beginTermination } = context;
+    beginTermination(agent, settings, `Provider produced no output for ${timing.timeSinceLastOutput}ms`, 'PROVIDER_INACTIVITY_TIMEOUT', {
+        taskId: agent.currentTaskId,
+        timeSinceLastOutput: timing.timeSinceLastOutput,
+        staleDuration,
+        consecutiveWarnings: agent.consecutiveStaleWarnings,
+    });
 }
-
 function createLivenessPoll(context) {
-  const { agent, settings, staleDuration, warningsBeforeKill, attemptTermination } = context;
-  return () => {
-    if (!hasRecoverableTask(agent) || agent.livenessTerminationStarted) return;
-    const now = Date.now();
-    if (handlePendingTermination(agent, settings, now, attemptTermination)) return;
-    const timing = taskTiming(agent, now);
-    if (handleTaskTimeout(context, timing)) return;
-    if (timing.timeSinceLastOutput < staleDuration) {
-      agent.consecutiveStaleWarnings = 0;
-      return;
-    }
-    publishStaleWarning(context, timing);
-    if (agent.consecutiveStaleWarnings < warningsBeforeKill) return;
-    terminateForInactivity(context, timing);
-  };
+    const { agent, settings, staleDuration, warningsBeforeKill, attemptTermination } = context;
+    return () => {
+        if (!hasRecoverableTask(agent) || agent.livenessTerminationStarted)
+            return;
+        const now = Date.now();
+        if (handlePendingTermination(agent, settings, now, attemptTermination))
+            return;
+        const timing = taskTiming(agent, now);
+        if (handleTaskTimeout(context, timing))
+            return;
+        if (timing.timeSinceLastOutput < staleDuration) {
+            agent.consecutiveStaleWarnings = 0;
+            return;
+        }
+        publishStaleWarning(context, timing);
+        if (agent.consecutiveStaleWarnings < warningsBeforeKill)
+            return;
+        terminateForInactivity(context, timing);
+    };
 }
-
 module.exports = { createLivenessPoll };

package/src/agent/agent-liveness-poll.ts

@@ -0,0 +1,163 @@
+interface AgentStuckDetectorModule {
+  isPlatformSupported(): boolean;
+}
+
+interface LivenessIsolation {
+  enabled?: boolean;
+}
+
+interface NestedExecutions {
+  hasActive?: boolean;
+}
+
+interface LivenessAgent {
+  currentTask?: unknown;
+  currentTaskId?: unknown;
+  isolation?: LivenessIsolation | null;
+  nestedExecutions?: NestedExecutions | null;
+  livenessTerminationStarted?: boolean;
+  livenessTerminationContext?: unknown;
+  livenessTerminationRetryAt: number;
+  taskStartedAt?: number | null;
+  lastOutputTime?: number | null;
+  consecutiveStaleWarnings: number;
+  _publishLifecycle(event: string, details: Record<string, unknown>): unknown;
+}
+
+interface TaskTiming {
+  taskRuntime: number;
+  timeSinceLastOutput: number;
+  lastOutputTime: number;
+}
+
+type AttemptTermination = (agent: LivenessAgent, settings: unknown) => unknown;
+
+type BeginTermination = (
+  agent: LivenessAgent,
+  settings: unknown,
+  reason: string,
+  code: string,
+  eventData: Record<string, unknown>
+) => unknown;
+
+interface LivenessPollContext {
+  agent: LivenessAgent;
+  settings: unknown;
+  configuredTimeout: number | null;
+  staleDuration: number;
+  warningsBeforeKill: number;
+  attemptTermination: AttemptTermination;
+  beginTermination: BeginTermination;
+}
+
+function isAgentStuckDetectorModule(value: unknown): value is AgentStuckDetectorModule {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'isPlatformSupported' in value &&
+    typeof value.isPlatformSupported === 'function'
+  );
+}
+
+const agentStuckDetectorModule: unknown = require('./agent-stuck-detector');
+if (!isAgentStuckDetectorModule(agentStuckDetectorModule)) {
+  throw new TypeError('agent-stuck-detector must export isPlatformSupported');
+}
+const isPlatformSupported = agentStuckDetectorModule.isPlatformSupported;
+
+function hasRecoverableTask(agent: LivenessAgent): boolean {
+  return (
+    Boolean(agent.currentTask) ||
+    Boolean(agent.isolation?.enabled && agent.currentTaskId) ||
+    agent.nestedExecutions?.hasActive === true
+  );
+}
+
+function handlePendingTermination(
+  agent: LivenessAgent,
+  settings: unknown,
+  now: number,
+  attemptTermination: AttemptTermination
+): boolean {
+  if (!agent.livenessTerminationContext) return false;
+  if (now >= agent.livenessTerminationRetryAt) attemptTermination(agent, settings);
+  return true;
+}
+
+function taskTiming(agent: LivenessAgent, now: number): TaskTiming {
+  const taskStartedAt = agent.taskStartedAt || agent.lastOutputTime || now;
+  const lastOutputTime = agent.lastOutputTime || taskStartedAt;
+  return {
+    taskRuntime: now - taskStartedAt,
+    timeSinceLastOutput: now - lastOutputTime,
+    lastOutputTime,
+  };
+}
+
+function handleTaskTimeout(context: LivenessPollContext, timing: TaskTiming): boolean {
+  const { agent, settings, configuredTimeout, beginTermination } = context;
+  if (!configuredTimeout || timing.taskRuntime < configuredTimeout) return false;
+  beginTermination(
+    agent,
+    settings,
+    `Task timed out after ${configuredTimeout}ms`,
+    'AGENT_TASK_TIMEOUT',
+    {
+      taskId: agent.currentTaskId,
+      taskRuntime: timing.taskRuntime,
+      timeout: configuredTimeout,
+    }
+  );
+  return true;
+}
+
+function publishStaleWarning(context: LivenessPollContext, timing: TaskTiming): void {
+  const { agent, staleDuration, warningsBeforeKill } = context;
+  agent.consecutiveStaleWarnings += 1;
+  agent._publishLifecycle('AGENT_STALE_WARNING', {
+    taskId: agent.currentTaskId,
+    timeSinceLastOutput: timing.timeSinceLastOutput,
+    staleDuration,
+    lastOutputTime: timing.lastOutputTime,
+    consecutiveWarnings: agent.consecutiveStaleWarnings,
+    warningsBeforeKill,
+    processDiagnosticsAvailable: isPlatformSupported(),
+    analysis: `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
+  });
+}
+
+function terminateForInactivity(context: LivenessPollContext, timing: TaskTiming): void {
+  const { agent, settings, staleDuration, beginTermination } = context;
+  beginTermination(
+    agent,
+    settings,
+    `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
+    'PROVIDER_INACTIVITY_TIMEOUT',
+    {
+      taskId: agent.currentTaskId,
+      timeSinceLastOutput: timing.timeSinceLastOutput,
+      staleDuration,
+      consecutiveWarnings: agent.consecutiveStaleWarnings,
+    }
+  );
+}
+
+function createLivenessPoll(context: LivenessPollContext): () => void {
+  const { agent, settings, staleDuration, warningsBeforeKill, attemptTermination } = context;
+  return () => {
+    if (!hasRecoverableTask(agent) || agent.livenessTerminationStarted) return;
+    const now = Date.now();
+    if (handlePendingTermination(agent, settings, now, attemptTermination)) return;
+    const timing = taskTiming(agent, now);
+    if (handleTaskTimeout(context, timing)) return;
+    if (timing.timeSinceLastOutput < staleDuration) {
+      agent.consecutiveStaleWarnings = 0;
+      return;
+    }
+    publishStaleWarning(context, timing);
+    if (agent.consecutiveStaleWarnings < warningsBeforeKill) return;
+    terminateForInactivity(context, timing);
+  };
+}
+
+export = { createLivenessPoll };

package/src/agent/agent-quality-gate-schema.js

@@ -1,102 +1,93 @@
+"use strict";
 function buildQualityGateSchema() {
-  return {
-    type: 'array',
-    description: 'Tool-neutral ship handoff quality gate evidence for configured required gates.',
-    items: {
-      type: 'object',
-      properties: {
-        id: {
-          type: 'string',
-          description: 'Stable gate id matching the configured required quality gate.',
-        },
-        name: {
-          type: 'string',
-          description: 'Optional display name for the gate.',
-        },
-        status: {
-          type: 'string',
-          enum: ['PASS', 'FAIL', 'UNAVAILABLE'],
-          description: 'PASS only when the gate completed successfully.',
-        },
-        scope: {
-          type: 'string',
-          description: 'Optional repo-defined scope for the gate.',
-        },
-        evidence: {
-          type: 'object',
-          properties: {
-            command: { type: 'string' },
-            exitCode: { type: 'integer' },
-            output: { type: 'string' },
-            proof: {
-              type: 'object',
-              description: 'Optional command proof metadata when the gate used cmdproof.',
-              properties: {
-                profile: { type: 'string' },
-                reused: { type: 'boolean' },
-                status: { type: 'string' },
-              },
+    return {
+        type: 'array',
+        description: 'Tool-neutral ship handoff quality gate evidence for configured required gates.',
+        items: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Stable gate id matching the configured required quality gate.',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Optional display name for the gate.',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['PASS', 'FAIL', 'UNAVAILABLE'],
+                    description: 'PASS only when the gate completed successfully.',
+                },
+                scope: {
+                    type: 'string',
+                    description: 'Optional repo-defined scope for the gate.',
+                },
+                evidence: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string' },
+                        exitCode: { type: 'integer' },
+                        output: { type: 'string' },
+                        proof: {
+                            type: 'object',
+                            description: 'Optional command proof metadata when the gate used cmdproof.',
+                            properties: {
+                                profile: { type: 'string' },
+                                reused: { type: 'boolean' },
+                                status: { type: 'string' },
+                            },
+                        },
+                    },
+                    required: ['command', 'exitCode', 'output'],
+                },
+                completedAt: {
+                    anyOf: [{ type: 'string' }, { type: 'number' }],
+                    description: 'When the gate completed, as an ISO string or numeric timestamp.',
+                },
+                timestamp: {
+                    anyOf: [{ type: 'string' }, { type: 'number' }],
+                    description: 'Alternate completion timestamp, as an ISO string or numeric timestamp.',
+                },
+                stale: {
+                    type: 'boolean',
+                    description: 'True when this evidence is known stale and must block handoff.',
+                },
+                reason: { type: 'string' },
             },
-          },
-          required: ['command', 'exitCode', 'output'],
-        },
-        completedAt: {
-          anyOf: [{ type: 'string' }, { type: 'number' }],
-          description: 'When the gate completed, as an ISO string or numeric timestamp.',
-        },
-        timestamp: {
-          anyOf: [{ type: 'string' }, { type: 'number' }],
-          description: 'Alternate completion timestamp, as an ISO string or numeric timestamp.',
-        },
-        stale: {
-          type: 'boolean',
-          description: 'True when this evidence is known stale and must block handoff.',
+            required: ['id', 'status', 'evidence'],
         },
-        reason: { type: 'string' },
-      },
-      required: ['id', 'status', 'evidence'],
-    },
-  };
+    };
 }
-
 function hasRequiredQualityGates(config) {
-  return Array.isArray(config.requiredQualityGates) && config.requiredQualityGates.length > 0;
+    return Array.isArray(config.requiredQualityGates) && config.requiredQualityGates.length > 0;
 }
-
 function shouldApplyValidatorQualityGateDefaults(config) {
-  return (
-    config.role === 'validator' && config.outputFormat === 'json' && hasRequiredQualityGates(config)
-  );
+    return (config.role === 'validator' && config.outputFormat === 'json' && hasRequiredQualityGates(config));
 }
-
 function applyValidatorQualityGateSchema(config) {
-  if (!shouldApplyValidatorQualityGateDefaults(config)) {
-    return;
-  }
-
-  const properties = config.jsonSchema?.properties;
-  if (properties && !properties.qualityGates) {
-    properties.qualityGates = buildQualityGateSchema();
-  }
+    if (!shouldApplyValidatorQualityGateDefaults(config)) {
+        return;
+    }
+    const properties = config.jsonSchema?.properties;
+    if (properties && !properties.qualityGates) {
+        properties.qualityGates = buildQualityGateSchema();
+    }
 }
-
 function applyValidatorQualityGatePublishMapping(config) {
-  if (!shouldApplyValidatorQualityGateDefaults(config)) {
-    return;
-  }
-
-  const data = config.hooks?.onComplete?.config?.content?.data;
-  if (data && data.qualityGates === undefined) {
-    data.qualityGates = '{{result.qualityGates}}';
-  }
+    if (!shouldApplyValidatorQualityGateDefaults(config)) {
+        return;
+    }
+    const data = config.hooks?.onComplete?.config?.content?.data;
+    if (data && data.qualityGates === undefined) {
+        data.qualityGates = '{{result.qualityGates}}';
+    }
 }
-
 function applyValidatorQualityGateDefaults(config) {
-  applyValidatorQualityGateSchema(config);
-  applyValidatorQualityGatePublishMapping(config);
+    applyValidatorQualityGateSchema(config);
+    applyValidatorQualityGatePublishMapping(config);
 }
-
 module.exports = {
-  applyValidatorQualityGateDefaults,
-  buildQualityGateSchema,
+    applyValidatorQualityGateDefaults,
+    buildQualityGateSchema,
 };

package/src/agent/agent-quality-gate-schema.ts

@@ -0,0 +1,135 @@
+type JsonSchemaType = 'array' | 'boolean' | 'integer' | 'number' | 'object' | 'string';
+
+interface JsonSchema {
+  type?: JsonSchemaType;
+  description?: string;
+  enum?: string[];
+  items?: JsonSchema;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  anyOf?: JsonSchema[];
+}
+
+interface QualityGatePublishData {
+  qualityGates?: unknown;
+  [key: string]: unknown;
+}
+
+interface AgentQualityGateConfig {
+  role?: string;
+  outputFormat?: string;
+  requiredQualityGates?: unknown;
+  jsonSchema?: JsonSchema;
+  hooks?: {
+    onComplete?: {
+      config?: {
+        content?: {
+          data?: QualityGatePublishData;
+        };
+      };
+    };
+  };
+}
+
+function buildQualityGateSchema(): JsonSchema {
+  return {
+    type: 'array',
+    description: 'Tool-neutral ship handoff quality gate evidence for configured required gates.',
+    items: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description: 'Stable gate id matching the configured required quality gate.',
+        },
+        name: {
+          type: 'string',
+          description: 'Optional display name for the gate.',
+        },
+        status: {
+          type: 'string',
+          enum: ['PASS', 'FAIL', 'UNAVAILABLE'],
+          description: 'PASS only when the gate completed successfully.',
+        },
+        scope: {
+          type: 'string',
+          description: 'Optional repo-defined scope for the gate.',
+        },
+        evidence: {
+          type: 'object',
+          properties: {
+            command: { type: 'string' },
+            exitCode: { type: 'integer' },
+            output: { type: 'string' },
+            proof: {
+              type: 'object',
+              description: 'Optional command proof metadata when the gate used cmdproof.',
+              properties: {
+                profile: { type: 'string' },
+                reused: { type: 'boolean' },
+                status: { type: 'string' },
+              },
+            },
+          },
+          required: ['command', 'exitCode', 'output'],
+        },
+        completedAt: {
+          anyOf: [{ type: 'string' }, { type: 'number' }],
+          description: 'When the gate completed, as an ISO string or numeric timestamp.',
+        },
+        timestamp: {
+          anyOf: [{ type: 'string' }, { type: 'number' }],
+          description: 'Alternate completion timestamp, as an ISO string or numeric timestamp.',
+        },
+        stale: {
+          type: 'boolean',
+          description: 'True when this evidence is known stale and must block handoff.',
+        },
+        reason: { type: 'string' },
+      },
+      required: ['id', 'status', 'evidence'],
+    },
+  };
+}
+
+function hasRequiredQualityGates(config: AgentQualityGateConfig): boolean {
+  return Array.isArray(config.requiredQualityGates) && config.requiredQualityGates.length > 0;
+}
+
+function shouldApplyValidatorQualityGateDefaults(config: AgentQualityGateConfig): boolean {
+  return (
+    config.role === 'validator' && config.outputFormat === 'json' && hasRequiredQualityGates(config)
+  );
+}
+
+function applyValidatorQualityGateSchema(config: AgentQualityGateConfig): void {
+  if (!shouldApplyValidatorQualityGateDefaults(config)) {
+    return;
+  }
+
+  const properties = config.jsonSchema?.properties;
+  if (properties && !properties.qualityGates) {
+    properties.qualityGates = buildQualityGateSchema();
+  }
+}
+
+function applyValidatorQualityGatePublishMapping(config: AgentQualityGateConfig): void {
+  if (!shouldApplyValidatorQualityGateDefaults(config)) {
+    return;
+  }
+
+  const data = config.hooks?.onComplete?.config?.content?.data;
+  if (data && data.qualityGates === undefined) {
+    data.qualityGates = '{{result.qualityGates}}';
+  }
+}
+
+function applyValidatorQualityGateDefaults(config: AgentQualityGateConfig): void {
+  applyValidatorQualityGateSchema(config);
+  applyValidatorQualityGatePublishMapping(config);
+}
+
+export = {
+  applyValidatorQualityGateDefaults,
+  buildQualityGateSchema,
+};