@botbotgo/agent-harness 0.0.102 → 0.0.104

package/dist/runtime/harness.d.ts

@@ -22,8 +22,6 @@ export declare class AgentHarnessRuntime {
     private readonly threadMemorySync;
     private readonly unregisterThreadMemorySync;
     private readonly resolvedRuntimeAdapterOptions;
-    private readonly checkpointMaintenance;
-    private readonly runtimeRecordMaintenance;
     private readonly healthMonitor;
     private readonly recoveryConfig;
     private readonly concurrencyConfig;

package/dist/runtime/harness.js

@@ -9,12 +9,9 @@ import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getR
 import { createHarnessEvent, inferRoutingBindings, renderRuntimeFailure, } from "./support/harness-support.js";
 import { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
 import { FileBackedStore } from "./harness/system/store.js";
-import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./maintenance/checkpoint-maintenance.js";
-import { RuntimeRecordMaintenanceLoop, discoverRuntimeRecordMaintenanceTargets, readRuntimeRecordMaintenanceConfig, } from "./maintenance/runtime-record-maintenance.js";
-import { HealthMonitor } from "./harness/system/health-monitor.js";
-import { readHealthMonitorConfig } from "./harness/system/health-monitor.js";
+import { HealthMonitor, readHealthMonitorConfig, } from "./harness/system/health-monitor.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
-import { buildPersistedRunRequest, isTerminalRunState, normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, toPublicApprovalRecord, } from "./harness/run/helpers.js";
+import { buildPersistedRunRequest, normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, } from "./harness/run/helpers.js";
 import { emitHarnessEvent, emitRunCreatedEvent, emitSyntheticFallbackEvent, requestApprovalAndEmitEvent, setRunStateAndEmitEvent, } from "./harness/events/events.js";
 import { appendAssistantMessage as appendLifecycleAssistantMessage, finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
 import { dispatchRunListeners as dispatchStreamingRunListeners, } from "./harness/events/streaming.js";
@@ -29,8 +26,9 @@ import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig }
 import { isRuntimeEntryBinding } from "./support/runtime-entry.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
-import { recoverQueuedStartupRun, recoverResumingStartupRun, recoverRunningStartupRun, } from "./harness/run/recovery.js";
+import { initializeHarnessRuntime, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
+import { deleteThreadRecord, getPublicApproval, getThreadRecord, listPublicApprovals, } from "./harness/run/thread-records.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -57,8 +55,6 @@ export class AgentHarnessRuntime {
     threadMemorySync;
     unregisterThreadMemorySync;
     resolvedRuntimeAdapterOptions;
-    checkpointMaintenance;
-    runtimeRecordMaintenance;
     healthMonitor;
     recoveryConfig;
     concurrencyConfig;
@@ -126,14 +122,6 @@ export class AgentHarnessRuntime {
             this.threadMemorySync = null;
             this.unregisterThreadMemorySync = () => { };
         }
-        const checkpointMaintenanceConfig = readCheckpointMaintenanceConfig(workspace);
-        this.checkpointMaintenance = checkpointMaintenanceConfig
-            ? new CheckpointMaintenanceLoop(discoverCheckpointMaintenanceTargets(workspace), checkpointMaintenanceConfig)
-            : null;
-        const runtimeRecordMaintenanceConfig = readRuntimeRecordMaintenanceConfig(workspace);
-        this.runtimeRecordMaintenance = runtimeRecordMaintenanceConfig
-            ? new RuntimeRecordMaintenanceLoop(discoverRuntimeRecordMaintenanceTargets(workspace), runtimeRecordMaintenanceConfig)
-            : null;
         this.recoveryConfig = getRecoveryConfig(workspace.refs);
         this.concurrencyConfig = getConcurrencyConfig(workspace.refs);
         const healthConfig = readHealthMonitorConfig(workspace);
@@ -145,8 +133,8 @@ export class AgentHarnessRuntime {
             persistence: this.persistence,
             getActiveRunSlots: () => this.activeRunSlots,
             getPendingRunSlots: () => this.pendingRunSlots.length,
-            getCheckpointMaintenanceStatus: () => this.checkpointMaintenance?.getStatus() ?? null,
-            getRuntimeRecordMaintenanceStatus: () => this.runtimeRecordMaintenance?.getStatus() ?? null,
+            getCheckpointMaintenanceStatus: () => null,
+            getRuntimeRecordMaintenanceStatus: () => null,
             publishEvent: async (payload) => {
                 this.eventBus.publish(createHarnessEvent("__runtime__", "__runtime__", ++this.runtimeEventSequence, "runtime.health.changed", payload));
             },
@@ -159,11 +147,10 @@ export class AgentHarnessRuntime {
         this.healthMonitor?.recordLlmFailure(Date.now() - startedAt);
     }
     async initialize() {
-        await this.persistence.initialize();
-        await this.checkpointMaintenance?.start();
-        await this.runtimeRecordMaintenance?.start();
-        await this.healthMonitor?.start();
-        await this.recoverStartupRuns();
+        await initializeHarnessRuntime({
+            persistence: this.persistence,
+            healthMonitor: this.healthMonitor,
+        });
     }
     subscribe(listener) {
         return this.eventBus.subscribe(listener);
@@ -204,47 +191,20 @@ export class AgentHarnessRuntime {
         return this.persistence.getSession(threadId);
     }
     async getThread(threadId) {
-        const [threadSummary, meta, messages, runs] = await Promise.all([
-            this.getSession(threadId),
-            this.persistence.getThreadMeta(threadId),
-            this.persistence.listThreadMessages(threadId, 200),
-            this.persistence.listThreadRuns(threadId),
-        ]);
-        if (!threadSummary || !meta) {
-            return null;
-        }
-        const latestRunId = threadSummary.latestRunId;
-        const latestApprovals = await this.persistence.getRunApprovals(threadId, latestRunId);
-        const pendingApproval = latestApprovals
-            .filter((approval) => approval.status === "pending")
-            .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
-        return {
-            threadId,
-            entryAgentId: meta.entryAgentId,
-            currentState: threadSummary.status,
-            latestRunId,
-            createdAt: meta.createdAt,
-            updatedAt: threadSummary.updatedAt,
-            messages,
-            runs,
-            pendingDecision: pendingApproval
-                ? {
-                    approvalId: pendingApproval.approvalId,
-                    pendingActionId: pendingApproval.pendingActionId,
-                    toolName: pendingApproval.toolName,
-                    allowedDecisions: pendingApproval.allowedDecisions,
-                    requestedAt: pendingApproval.requestedAt,
-                }
-                : undefined,
-        };
+        return getThreadRecord({
+            persistence: this.persistence,
+            getSession: (currentThreadId) => this.getSession(currentThreadId),
+        }, threadId);
     }
     async listApprovals(filter) {
-        const approvals = await this.persistence.listApprovals(filter);
-        return approvals.map((approval) => toPublicApprovalRecord(approval));
+        return listPublicApprovals({
+            persistence: this.persistence,
+        }, filter);
     }
     async getApproval(approvalId) {
-        const approval = await this.persistence.getApproval(approvalId);
-        return approval ? toPublicApprovalRecord(approval) : null;
+        return getPublicApproval({
+            persistence: this.persistence,
+        }, approvalId);
     }
     listAgentSkills(agentId, options = {}) {
         return listWorkspaceAgentSkills(this.workspace, agentId, {
@@ -277,19 +237,11 @@ export class AgentHarnessRuntime {
         }
     }
     async deleteThread(threadId) {
-        const thread = await this.getThread(threadId);
-        if (!thread) {
-            return false;
-        }
-        const activeRun = thread.runs.find((run) => !isTerminalRunState(run.state));
-        if (activeRun) {
-            throw new Error(`Cannot delete thread ${threadId} while run ${activeRun.runId} is ${activeRun.state}`);
-        }
-        const deleted = await this.persistence.deleteThread(threadId);
-        if (deleted) {
-            await this.deleteThreadCheckpoints(threadId);
-        }
-        return deleted;
+        return deleteThreadRecord({
+            getThread: (currentThreadId) => this.getThread(currentThreadId),
+            deleteThread: (currentThreadId) => this.persistence.deleteThread(currentThreadId),
+            deleteThreadCheckpoints: (currentThreadId) => this.deleteThreadCheckpoints(currentThreadId),
+        }, threadId);
     }
     async createToolMcpServer(options) {
         const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
@@ -752,8 +704,6 @@ export class AgentHarnessRuntime {
     }
     async close() {
         await this.healthMonitor?.stop();
-        await this.checkpointMaintenance?.stop();
-        await this.runtimeRecordMaintenance?.stop();
         this.unregisterThreadMemorySync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync?.close();
@@ -771,63 +721,15 @@ export class AgentHarnessRuntime {
         }, options);
     }
     async recoverStartupRuns() {
-        if (!this.recoveryConfig.enabled) {
-            return;
-        }
-        await this.reclaimExpiredClaimedRuns();
-        const threads = await this.persistence.listSessions();
-        const recoveryContext = this.createStartupRecoveryContext();
-        for (const thread of threads) {
-            const handled = await recoverQueuedStartupRun(recoveryContext, thread) ||
-                await recoverRunningStartupRun(recoveryContext, thread) ||
-                await recoverResumingStartupRun(recoveryContext, thread);
-            if (handled) {
-                continue;
-            }
-        }
+        return;
     }
-    async reclaimExpiredClaimedRuns(nowIso = new Date().toISOString()) {
-        const expiredClaims = await this.persistence.listExpiredClaimedRuns(nowIso);
-        for (const claim of expiredClaims) {
-            const thread = await this.persistence.getSession(claim.threadId);
-            if (!thread) {
-                await this.persistence.releaseRunClaim(claim.runId);
-                continue;
-            }
-            const lifecycle = await this.persistence.getRunLifecycle(claim.threadId, claim.runId);
-            if (lifecycle.state === "claimed") {
-                await this.persistence.enqueueRun({
-                    threadId: claim.threadId,
-                    runId: claim.runId,
-                    priority: claim.priority,
-                    queueKey: claim.queueKey,
-                    availableAt: nowIso,
-                });
-                await this.setRunStateAndEmit(claim.threadId, claim.runId, 99, "queued", {
-                    previousState: "claimed",
-                });
-                await this.emit(claim.threadId, claim.runId, 100, "run.queued", {
-                    queuePosition: 0,
-                    activeRunCount: this.activeRunSlots,
-                    maxConcurrentRuns: this.concurrencyConfig.maxConcurrentRuns,
-                    recoveredOnStartup: true,
-                    reclaimReason: "expired-lease",
-                });
-                continue;
-            }
-            await this.persistence.releaseRunClaim(claim.runId);
-        }
+    async reclaimExpiredClaimedRuns(_nowIso = new Date().toISOString()) {
+        return;
     }
     async isStaleRunningRun(thread, nowMs = Date.now()) {
-        const control = await this.persistence.getRunControl(thread.latestRunId);
-        const heartbeatAt = control?.heartbeatAt;
-        if (!heartbeatAt) {
-            return true;
-        }
-        const heartbeatAtMs = Date.parse(heartbeatAt);
-        if (!Number.isFinite(heartbeatAtMs)) {
-            return true;
-        }
-        return nowMs - heartbeatAtMs >= this.concurrencyConfig.heartbeatTimeoutMs;
+        return isHarnessStaleRunningRun({
+            persistence: this.persistence,
+            concurrencyConfig: this.concurrencyConfig,
+        }, thread, nowMs);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.102",
+  "version": "0.0.104",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",