@botbotgo/agent-harness 0.0.102 → 0.0.103

package/dist/runtime/harness/run/thread-records.js

@@ -0,0 +1,59 @@
+import { isTerminalRunState, toPublicApprovalRecord } from "./helpers.js";
+export async function getThreadRecord(input, threadId) {
+    const [threadSummary, meta, messages, runs] = await Promise.all([
+        input.getSession(threadId),
+        input.persistence.getThreadMeta(threadId),
+        input.persistence.listThreadMessages(threadId, 200),
+        input.persistence.listThreadRuns(threadId),
+    ]);
+    if (!threadSummary || !meta) {
+        return null;
+    }
+    const latestRunId = threadSummary.latestRunId;
+    const latestApprovals = await input.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,
+    };
+}
+export async function listPublicApprovals(input, filter) {
+    const approvals = await input.persistence.listApprovals(filter);
+    return approvals.map((approval) => toPublicApprovalRecord(approval));
+}
+export async function getPublicApproval(input, approvalId) {
+    const approval = await input.persistence.getApproval(approvalId);
+    return approval ? toPublicApprovalRecord(approval) : null;
+}
+export async function deleteThreadRecord(input, threadId) {
+    const thread = await input.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 input.deleteThread(threadId);
+    if (deleted) {
+        await input.deleteThreadCheckpoints(threadId);
+    }
+    return deleted;
+}

package/dist/runtime/harness.js

@@ -14,7 +14,7 @@ import { RuntimeRecordMaintenanceLoop, discoverRuntimeRecordMaintenanceTargets,
 import { HealthMonitor } from "./harness/system/health-monitor.js";
 import { 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 +29,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, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, } 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;
@@ -159,11 +160,13 @@ 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,
+            checkpointMaintenance: this.checkpointMaintenance,
+            runtimeRecordMaintenance: this.runtimeRecordMaintenance,
+            healthMonitor: this.healthMonitor,
+            recoverStartupRuns: () => this.recoverStartupRuns(),
+        });
     }
     subscribe(listener) {
         return this.eventBus.subscribe(listener);
@@ -204,47 +207,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 +253,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 }) => ({
@@ -771,63 +739,26 @@ 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;
-            }
-        }
+        await recoverHarnessStartupRuns({
+            recoveryConfig: this.recoveryConfig,
+            persistence: this.persistence,
+            createStartupRecoveryContext: () => this.createStartupRecoveryContext(),
+            reclaimExpiredClaimedRuns: (nowIso) => this.reclaimExpiredClaimedRuns(nowIso),
+        });
     }
     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);
-        }
+        await reclaimHarnessExpiredClaimedRuns({
+            persistence: this.persistence,
+            setRunStateAndEmit: (threadId, runId, sequence, state, options) => this.setRunStateAndEmit(threadId, runId, sequence, state, options),
+            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+            concurrencyConfig: this.concurrencyConfig,
+            getActiveRunSlots: () => this.activeRunSlots,
+        }, nowIso);
     }
     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.103",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",