@botbotgo/agent-harness 0.0.100 → 0.0.101

package/dist/runtime/harness/run/recovery.js

@@ -0,0 +1,139 @@
+import { normalizeRunPriority } from "./helpers.js";
+export async function recoverQueuedStartupRun(context, thread) {
+    if (thread.status !== "queued") {
+        return false;
+    }
+    const runMeta = await context.persistence.getRunMeta(thread.threadId, thread.latestRunId);
+    const binding = context.getBinding(runMeta.agentId);
+    if (!binding) {
+        return true;
+    }
+    const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
+    if (!request) {
+        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
+            previousState: "queued",
+            error: "missing persisted run request for queued run recovery",
+        });
+        return true;
+    }
+    const releaseRunSlot = await context.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
+    try {
+        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, runMeta.agentId, {
+            context: request.invocation?.context,
+            state: request.invocation?.inputs,
+            files: request.invocation?.attachments,
+            previousState: "queued",
+            stateSequence: 103,
+            approvalSequence: 104,
+        });
+    }
+    finally {
+        await releaseRunSlot();
+    }
+    return true;
+}
+export async function recoverRunningStartupRun(context, thread) {
+    if (thread.status !== "running") {
+        return false;
+    }
+    const isStale = await context.isStaleRunningRun(thread);
+    if (!isStale) {
+        return true;
+    }
+    const runMeta = await context.persistence.getRunMeta(thread.threadId, thread.latestRunId);
+    const binding = context.getBinding(runMeta.agentId);
+    if (!binding) {
+        return true;
+    }
+    if (!context.supportsRunningReplay(binding)) {
+        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
+            previousState: "running",
+            error: "stale running run cannot be replayed safely",
+        });
+        await context.persistence.releaseRunClaim(thread.latestRunId);
+        return true;
+    }
+    const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
+    if (!request) {
+        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
+            previousState: "running",
+            error: "missing persisted run request for stale running run recovery",
+        });
+        await context.persistence.releaseRunClaim(thread.latestRunId);
+        return true;
+    }
+    const releaseRunSlot = await context.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
+    try {
+        await context.emit(thread.threadId, thread.latestRunId, 100, "run.resumed", {
+            resumeKind: "startup-running-recovery",
+            state: "running",
+        });
+        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, runMeta.agentId, {
+            context: request.invocation?.context,
+            state: request.invocation?.inputs,
+            files: request.invocation?.attachments,
+            previousState: "running",
+            stateSequence: 103,
+            approvalSequence: 104,
+        });
+    }
+    finally {
+        await releaseRunSlot();
+    }
+    return true;
+}
+export async function recoverResumingStartupRun(context, thread) {
+    if (thread.status !== "resuming" || !context.recoveryConfig.resumeResumingRunsOnStartup) {
+        return false;
+    }
+    const binding = context.getBinding(thread.agentId);
+    if (!binding) {
+        return true;
+    }
+    const recoveryIntent = await context.persistence.getRecoveryIntent(thread.threadId, thread.latestRunId);
+    if (!recoveryIntent || recoveryIntent.kind !== "approval-decision") {
+        return true;
+    }
+    if (recoveryIntent.attempts >= context.recoveryConfig.maxRecoveryAttempts) {
+        await context.persistence.setRunState(thread.threadId, thread.latestRunId, "failed", recoveryIntent.checkpointRef);
+        await context.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
+        return true;
+    }
+    await context.persistence.saveRecoveryIntent(thread.threadId, thread.latestRunId, {
+        ...recoveryIntent,
+        attempts: recoveryIntent.attempts + 1,
+    });
+    await context.emit(thread.threadId, thread.latestRunId, 100, "run.resumed", {
+        resumeKind: "startup-recovery",
+        checkpointRef: recoveryIntent.checkpointRef,
+        state: "resuming",
+    });
+    const history = await context.persistence.listThreadMessages(thread.threadId);
+    const priorHistory = history.filter((message) => message.runId !== thread.latestRunId);
+    const runInput = await context.loadRunInput(thread.threadId, thread.latestRunId);
+    const startedAt = Date.now();
+    try {
+        const actual = await context.runtimeAdapter.invoke(binding, "", thread.threadId, thread.latestRunId, recoveryIntent.resumePayload, priorHistory);
+        context.recordLlmSuccess(startedAt);
+        await context.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
+        await context.finalizeContinuedRun(binding, thread.threadId, thread.latestRunId, runInput, actual, {
+            previousState: "resuming",
+            stateSequence: 101,
+            approvalSequence: 102,
+        });
+    }
+    catch (error) {
+        context.recordLlmFailure(startedAt);
+        if (recoveryIntent.attempts + 1 >= context.recoveryConfig.maxRecoveryAttempts) {
+            await context.persistence.setRunState(thread.threadId, thread.latestRunId, "failed", recoveryIntent.checkpointRef);
+            await context.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
+            await context.emit(thread.threadId, thread.latestRunId, 101, "run.state.changed", {
+                previousState: "resuming",
+                state: "failed",
+                checkpointRef: recoveryIntent.checkpointRef,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return true;
+}

package/dist/runtime/harness.d.ts

@@ -37,10 +37,6 @@ export declare class AgentHarnessRuntime {
     private defaultRunRoot;
     private getDefaultHostAgentId;
     private resolveSelectedAgentId;
-    private resolveStore;
-    private resolveStoreFromConfig;
-    private resolveEmbeddingModel;
-    private resolveVectorStore;
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
     private createHealthMonitor;
     private recordLlmSuccess;
@@ -48,8 +44,6 @@ export declare class AgentHarnessRuntime {
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
     getHealth(): Promise<RuntimeHealthSnapshot>;
-    private getBinding;
-    private listAgentTools;
     private resolveAgentTools;
     private supportsRunningReplay;
     listThreads(filter?: {
@@ -86,34 +80,25 @@ export declare class AgentHarnessRuntime {
     private ensureThreadStarted;
     private loadPriorHistory;
     private loadRunInput;
-    private appendAssistantMessage;
     private getRunCancellation;
-    private expirePendingApprovals;
     private finalizeCancelledRun;
     private invokeWithHistory;
     private resolvePersistedRunPriority;
     private enqueuePendingRunSlot;
     private executeQueuedRun;
-    private checkpointRefForState;
     private finalizeContinuedRun;
-    private emitOutputDeltaAndCreateItem;
-    private createContentBlocksItem;
-    private createToolResultKey;
-    private emitRunCreated;
     private setRunStateAndEmit;
     private requestApprovalAndEmit;
-    private emitSyntheticFallback;
-    private persistApproval;
-    private resolveApprovalRecord;
     private isDecisionRun;
     private notifyListener;
+    private prepareRunStart;
+    private createStartupRecoveryContext;
     private acquireRunSlot;
     private dropPendingRunSlot;
     private dispatchRunListeners;
     run(options: RunOptions): Promise<RunResult>;
     streamEvents(options: RunStartOptions): AsyncGenerator<HarnessStreamItem>;
     resume(options: ResumeOptions): Promise<RunResult>;
-    private buildResumePayload;
     restartConversation(options: RestartConversationOptions): Promise<RunResult & {
         restart: Record<string, string>;
     }>;