@the-open-engine/zeroshot 6.38.0 → 6.39.0

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,
+};

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 };