@the-open-engine/zeroshot 6.38.1 → 6.39.1

package/src/agent/agent-context-validation-sections.js

@@ -0,0 +1,73 @@
+"use strict";
+const validationPlatform = require("./validation-platform");
+const { isPlatformMismatchReason } = validationPlatform;
+function shouldKeepCannotValidate(criteria, ignoreReason, seenIds) {
+    if (criteria.status !== 'CANNOT_VALIDATE' || !criteria.id) {
+        return false;
+    }
+    if (ignoreReason && ignoreReason(criteria.reason)) {
+        return false;
+    }
+    if (seenIds.has(criteria.id)) {
+        return false;
+    }
+    return true;
+}
+function isValidationCriteria(value) {
+    return Array.isArray(value);
+}
+function collectCannotValidateCriteria(prevValidations, options = {}) {
+    const cannotValidateCriteria = [];
+    const seenIds = new Set();
+    const ignoreReason = options.ignoreReason;
+    for (const msg of prevValidations) {
+        const criteriaResults = msg.content?.data?.criteriaResults;
+        if (!isValidationCriteria(criteriaResults)) {
+            continue;
+        }
+        for (const criteria of criteriaResults) {
+            if (!shouldKeepCannotValidate(criteria, ignoreReason, seenIds)) {
+                continue;
+            }
+            seenIds.add(criteria.id);
+            cannotValidateCriteria.push({
+                id: criteria.id,
+                reason: criteria.reason || 'No reason provided',
+            });
+        }
+    }
+    return cannotValidateCriteria;
+}
+function buildCannotValidateSection(cannotValidateCriteria) {
+    if (cannotValidateCriteria.length === 0) {
+        return '';
+    }
+    return [
+        '',
+        '## ⚠️ Permanently Unverifiable Criteria (SKIP THESE)',
+        '',
+        'The following criteria have PERMANENT environmental limitations (missing tools, no access).',
+        'These limitations have not changed. Do NOT re-attempt verification.',
+        'Mark these as CANNOT_VALIDATE again with the same reason.',
+        '',
+        ...cannotValidateCriteria.map((criteria) => `- **${criteria.id}**: ${criteria.reason}`),
+        '',
+    ].join('\n');
+}
+function buildValidatorSkipSection({ role, messageBus, cluster, isolation, }) {
+    if (role !== 'validator') {
+        return '';
+    }
+    const prevValidations = messageBus.query({
+        cluster_id: cluster.id,
+        topic: 'VALIDATION_RESULT',
+        since: cluster.createdAt,
+        limit: 50,
+    });
+    const ignoreReason = isolation?.enabled ? isPlatformMismatchReason : null;
+    const cannotValidateCriteria = collectCannotValidateCriteria(prevValidations, { ignoreReason });
+    return buildCannotValidateSection(cannotValidateCriteria);
+}
+module.exports = {
+    buildValidatorSkipSection,
+};

package/src/agent/agent-context-validation-sections.ts

@@ -0,0 +1,129 @@
+import validationPlatform = require('./validation-platform');
+
+import type {
+  ContextCluster,
+  ContextMessage,
+  ContextMessageBus,
+  IsolationContext,
+  ValidationCriterion,
+} from './agent-context-types';
+
+interface CannotValidateCriterion {
+  id: string;
+  reason: string;
+}
+
+interface CannotValidateOptions {
+  ignoreReason?: ((reason: string | undefined) => boolean) | null;
+}
+
+interface ValidatorSkipParams {
+  role: string;
+  messageBus: ContextMessageBus;
+  cluster: ContextCluster;
+  isolation?: IsolationContext | null | undefined;
+}
+
+const { isPlatformMismatchReason } = validationPlatform;
+
+function shouldKeepCannotValidate(
+  criteria: ValidationCriterion,
+  ignoreReason: CannotValidateOptions['ignoreReason'],
+  seenIds: ReadonlySet<string>
+): criteria is ValidationCriterion & { id: string } {
+  if (criteria.status !== 'CANNOT_VALIDATE' || !criteria.id) {
+    return false;
+  }
+
+  if (ignoreReason && ignoreReason(criteria.reason)) {
+    return false;
+  }
+
+  if (seenIds.has(criteria.id)) {
+    return false;
+  }
+
+  return true;
+}
+
+function isValidationCriteria(
+  value: readonly ValidationCriterion[] | null | undefined
+): value is readonly ValidationCriterion[] {
+  return Array.isArray(value);
+}
+
+function collectCannotValidateCriteria(
+  prevValidations: readonly ContextMessage[],
+  options: CannotValidateOptions = {}
+): CannotValidateCriterion[] {
+  const cannotValidateCriteria: CannotValidateCriterion[] = [];
+  const seenIds = new Set<string>();
+  const ignoreReason = options.ignoreReason;
+
+  for (const msg of prevValidations) {
+    const criteriaResults = msg.content?.data?.criteriaResults;
+    if (!isValidationCriteria(criteriaResults)) {
+      continue;
+    }
+
+    for (const criteria of criteriaResults) {
+      if (!shouldKeepCannotValidate(criteria, ignoreReason, seenIds)) {
+        continue;
+      }
+
+      seenIds.add(criteria.id);
+      cannotValidateCriteria.push({
+        id: criteria.id,
+        reason: criteria.reason || 'No reason provided',
+      });
+    }
+  }
+
+  return cannotValidateCriteria;
+}
+
+function buildCannotValidateSection(
+  cannotValidateCriteria: readonly CannotValidateCriterion[]
+): string {
+  if (cannotValidateCriteria.length === 0) {
+    return '';
+  }
+
+  return [
+    '',
+    '## ⚠️ Permanently Unverifiable Criteria (SKIP THESE)',
+    '',
+    'The following criteria have PERMANENT environmental limitations (missing tools, no access).',
+    'These limitations have not changed. Do NOT re-attempt verification.',
+    'Mark these as CANNOT_VALIDATE again with the same reason.',
+    '',
+    ...cannotValidateCriteria.map((criteria) => `- **${criteria.id}**: ${criteria.reason}`),
+    '',
+  ].join('\n');
+}
+
+function buildValidatorSkipSection({
+  role,
+  messageBus,
+  cluster,
+  isolation,
+}: ValidatorSkipParams): string {
+  if (role !== 'validator') {
+    return '';
+  }
+
+  const prevValidations = messageBus.query({
+    cluster_id: cluster.id,
+    topic: 'VALIDATION_RESULT',
+    since: cluster.createdAt,
+    limit: 50,
+  });
+  const ignoreReason = isolation?.enabled ? isPlatformMismatchReason : null;
+  const cannotValidateCriteria = collectCannotValidateCriteria(prevValidations, { ignoreReason });
+
+  return buildCannotValidateSection(cannotValidateCriteria);
+}
+
+export = {
+  buildValidatorSkipSection,
+};

package/src/agent/agent-input-injector.js

@@ -1,141 +1,122 @@
-/**
- * AgentInputInjector - Live guidance injection for running agents
- *
- * Resolves the current task, validates attachable socket availability,
- * and sends input via attach STDIN when possible.
- */
-
-const { getTask } = require('../../task-lib/store.js');
-const { sendInput } = require('../attach/send-input');
-const { isSocketAlive } = require('../attach/socket-discovery');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+function isTaskStoreModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'getTask' in value &&
+        typeof value.getTask === 'function');
+}
+const taskStoreModule = require('../../task-lib/store.js');
+if (!isTaskStoreModule(taskStoreModule)) {
+    throw new TypeError('task store must export getTask');
+}
+const getTask = taskStoreModule.getTask;
+const send_input_1 = __importDefault(require("../attach/send-input"));
+const { sendInput } = send_input_1.default;
+const socket_discovery_1 = __importDefault(require("../attach/socket-discovery"));
+const { isSocketAlive } = socket_discovery_1.default;
 const DEFAULT_TIMEOUT_MS = 1500;
-
-function buildResult({ status, reason = null, method = null, taskId = null }) {
-  return {
-    status,
-    reason,
-    method,
-    taskId,
-  };
+function buildResult({ status, reason = null, method = null, taskId = null, }) {
+    return {
+        status,
+        reason,
+        method,
+        taskId,
+    };
 }
-
 function ensureValidInputs(agent, text) {
-  if (!agent) {
-    throw new Error('AgentInputInjector: agent is required');
-  }
-  if (typeof text !== 'string') {
-    throw new Error('AgentInputInjector: text must be a string');
-  }
-  if (!text.trim()) {
-    throw new Error('AgentInputInjector: text cannot be empty');
-  }
+    if (!agent) {
+        throw new Error('AgentInputInjector: agent is required');
+    }
+    if (typeof text !== 'string') {
+        throw new Error('AgentInputInjector: text must be a string');
+    }
+    if (!text.trim()) {
+        throw new Error('AgentInputInjector: text cannot be empty');
+    }
+    return { agent, text };
 }
-
 function buildUnsupported(reason, taskId) {
-  return buildResult({
-    status: 'unsupported',
-    reason,
-    taskId,
-  });
+    return buildResult({
+        status: 'unsupported',
+        reason,
+        taskId,
+    });
 }
-
 function getTaskId(agent) {
-  return agent.currentTaskId || null;
+    return agent.currentTaskId || null;
 }
-
 function checkIsolation(agent, taskId) {
-  if (agent.isolation?.enabled) {
-    return buildUnsupported('isolation-enabled', taskId);
-  }
-  return null;
-}
-
-function checkTaskId(taskId) {
-  if (!taskId) {
-    return buildUnsupported('no-current-task', null);
-  }
-  return null;
-}
-
-function checkTaskInfo(taskInfo, taskId) {
-  if (!taskInfo) {
-    return buildUnsupported('task-not-found', taskId);
-  }
-  if (!taskInfo.socketPath) {
-    return buildUnsupported('no-socket', taskId);
-  }
-  if (!taskInfo.attachable) {
-    return buildUnsupported('task-not-attachable', taskId);
-  }
-  return null;
+    if (agent.isolation?.enabled) {
+        return buildUnsupported('isolation-enabled', taskId);
+    }
+    return null;
 }
-
 async function checkSocketAlive(socketPath, taskId) {
-  const socketAlive = await isSocketAlive(socketPath);
-  if (!socketAlive) {
-    return buildUnsupported('socket-not-alive', taskId);
-  }
-  return null;
+    const socketAlive = await isSocketAlive(socketPath);
+    if (!socketAlive) {
+        return buildUnsupported('socket-not-alive', taskId);
+    }
+    return null;
 }
-
 function normalizePayload(text) {
-  return text.endsWith('\n') ? text : `${text}\n`;
+    return text.endsWith('\n') ? text : `${text}\n`;
 }
-
 function resolveTimeout(options) {
-  return options.timeoutMs || DEFAULT_TIMEOUT_MS;
+    return options.timeoutMs || DEFAULT_TIMEOUT_MS;
 }
-
 function buildInjected(taskId) {
-  return buildResult({
-    status: 'injected',
-    method: 'pty',
-    taskId,
-  });
+    return buildResult({
+        status: 'injected',
+        method: 'pty',
+        taskId,
+    });
 }
-
 function buildSendFailure(reason, taskId) {
-  return buildResult({
-    status: 'unsupported',
-    reason: reason || 'send-failed',
-    method: 'pty',
-    taskId,
-  });
+    return buildResult({
+        status: 'unsupported',
+        reason: reason || 'send-failed',
+        method: 'pty',
+        taskId,
+    });
 }
-
-async function injectInput(agent, text, options = {}) {
-  ensureValidInputs(agent, text);
-
-  const taskId = getTaskId(agent);
-  const isolationResult = checkIsolation(agent, taskId);
-  if (isolationResult) return isolationResult;
-
-  const taskIdResult = checkTaskId(taskId);
-  if (taskIdResult) return taskIdResult;
-
-  const taskInfo = getTask(taskId);
-  const taskInfoResult = checkTaskInfo(taskInfo, taskId);
-  if (taskInfoResult) return taskInfoResult;
-
-  const socketResult = await checkSocketAlive(taskInfo.socketPath, taskId);
-  if (socketResult) return socketResult;
-
-  const payload = normalizePayload(text);
-  const timeoutMs = resolveTimeout(options);
-  const result = await sendInput({
-    socketPath: taskInfo.socketPath,
-    data: payload,
-    timeoutMs,
-  });
-
-  if (!result.ok) {
-    return buildSendFailure(result.error, taskId);
-  }
-
-  return buildInjected(taskId);
+async function injectInput(agentValue, textValue, options = {}) {
+    const { agent, text } = ensureValidInputs(agentValue, textValue);
+    const taskId = getTaskId(agent);
+    const isolationResult = checkIsolation(agent, taskId);
+    if (isolationResult)
+        return isolationResult;
+    if (!taskId) {
+        return buildUnsupported('no-current-task', null);
+    }
+    const taskInfo = getTask(taskId);
+    if (!taskInfo) {
+        return buildUnsupported('task-not-found', taskId);
+    }
+    if (!taskInfo.socketPath) {
+        return buildUnsupported('no-socket', taskId);
+    }
+    if (!taskInfo.attachable) {
+        return buildUnsupported('task-not-attachable', taskId);
+    }
+    const socketPath = taskInfo.socketPath;
+    const socketResult = await checkSocketAlive(socketPath, taskId);
+    if (socketResult)
+        return socketResult;
+    const payload = normalizePayload(text);
+    const timeoutMs = resolveTimeout(options);
+    const result = await sendInput({
+        socketPath,
+        data: payload,
+        timeoutMs,
+    });
+    if (!result.ok) {
+        return buildSendFailure(result.error, taskId);
+    }
+    return buildInjected(taskId);
 }
-
 module.exports = {
-  injectInput,
+    injectInput,
 };

package/src/agent/agent-input-injector.ts

@@ -0,0 +1,195 @@
+type InjectionStatus = 'unsupported' | 'injected';
+type InjectionMethod = 'pty';
+
+interface InjectionResult {
+  status: InjectionStatus;
+  reason: string | null;
+  method: InjectionMethod | null;
+  taskId: string | null;
+}
+
+interface BuildResultParams {
+  status: InjectionStatus;
+  reason?: string | null | undefined;
+  method?: InjectionMethod | null | undefined;
+  taskId?: string | null | undefined;
+}
+
+interface AgentInputTarget {
+  currentTaskId?: string | null;
+  isolation?: {
+    enabled?: unknown;
+  } | null;
+}
+
+interface TaskInfo {
+  socketPath?: string | null;
+  attachable?: unknown;
+}
+
+interface TaskStoreModule {
+  getTask(taskId: string): TaskInfo | null | undefined;
+}
+
+interface InjectInputOptions {
+  timeoutMs?: number;
+}
+
+function isTaskStoreModule(value: unknown): value is TaskStoreModule {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'getTask' in value &&
+    typeof value.getTask === 'function'
+  );
+}
+
+const taskStoreModule: unknown = require('../../task-lib/store.js');
+if (!isTaskStoreModule(taskStoreModule)) {
+  throw new TypeError('task store must export getTask');
+}
+const getTask = taskStoreModule.getTask;
+
+import sendInputModule from '../attach/send-input';
+
+const { sendInput } = sendInputModule;
+
+import socketDiscovery from '../attach/socket-discovery';
+
+const { isSocketAlive } = socketDiscovery;
+
+const DEFAULT_TIMEOUT_MS = 1500;
+
+function buildResult({
+  status,
+  reason = null,
+  method = null,
+  taskId = null,
+}: BuildResultParams): InjectionResult {
+  return {
+    status,
+    reason,
+    method,
+    taskId,
+  };
+}
+
+function ensureValidInputs(
+  agent: AgentInputTarget | null | undefined,
+  text: unknown
+): { agent: AgentInputTarget; text: string } {
+  if (!agent) {
+    throw new Error('AgentInputInjector: agent is required');
+  }
+  if (typeof text !== 'string') {
+    throw new Error('AgentInputInjector: text must be a string');
+  }
+  if (!text.trim()) {
+    throw new Error('AgentInputInjector: text cannot be empty');
+  }
+  return { agent, text };
+}
+
+function buildUnsupported(reason: string, taskId: string | null): InjectionResult {
+  return buildResult({
+    status: 'unsupported',
+    reason,
+    taskId,
+  });
+}
+
+function getTaskId(agent: AgentInputTarget): string | null {
+  return agent.currentTaskId || null;
+}
+
+function checkIsolation(agent: AgentInputTarget, taskId: string | null): InjectionResult | null {
+  if (agent.isolation?.enabled) {
+    return buildUnsupported('isolation-enabled', taskId);
+  }
+  return null;
+}
+
+async function checkSocketAlive(
+  socketPath: string,
+  taskId: string
+): Promise<InjectionResult | null> {
+  const socketAlive = await isSocketAlive(socketPath);
+  if (!socketAlive) {
+    return buildUnsupported('socket-not-alive', taskId);
+  }
+  return null;
+}
+
+function normalizePayload(text: string): string {
+  return text.endsWith('\n') ? text : `${text}\n`;
+}
+
+function resolveTimeout(options: InjectInputOptions): number {
+  return options.timeoutMs || DEFAULT_TIMEOUT_MS;
+}
+
+function buildInjected(taskId: string): InjectionResult {
+  return buildResult({
+    status: 'injected',
+    method: 'pty',
+    taskId,
+  });
+}
+
+function buildSendFailure(reason: string | null | undefined, taskId: string): InjectionResult {
+  return buildResult({
+    status: 'unsupported',
+    reason: reason || 'send-failed',
+    method: 'pty',
+    taskId,
+  });
+}
+
+async function injectInput(
+  agentValue: AgentInputTarget | null | undefined,
+  textValue: unknown,
+  options: InjectInputOptions = {}
+): Promise<InjectionResult> {
+  const { agent, text } = ensureValidInputs(agentValue, textValue);
+
+  const taskId = getTaskId(agent);
+  const isolationResult = checkIsolation(agent, taskId);
+  if (isolationResult) return isolationResult;
+
+  if (!taskId) {
+    return buildUnsupported('no-current-task', null);
+  }
+
+  const taskInfo = getTask(taskId);
+  if (!taskInfo) {
+    return buildUnsupported('task-not-found', taskId);
+  }
+  if (!taskInfo.socketPath) {
+    return buildUnsupported('no-socket', taskId);
+  }
+  if (!taskInfo.attachable) {
+    return buildUnsupported('task-not-attachable', taskId);
+  }
+
+  const socketPath = taskInfo.socketPath;
+  const socketResult = await checkSocketAlive(socketPath, taskId);
+  if (socketResult) return socketResult;
+
+  const payload = normalizePayload(text);
+  const timeoutMs = resolveTimeout(options);
+  const result = await sendInput({
+    socketPath,
+    data: payload,
+    timeoutMs,
+  });
+
+  if (!result.ok) {
+    return buildSendFailure(result.error, taskId);
+  }
+
+  return buildInjected(taskId);
+}
+
+export = {
+  injectInput,
+};