@botbotgo/agent-harness 0.0.99 → 0.0.101

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

@@ -42,17 +42,11 @@ export function normalizeRunPriority(priority) {
     return Math.trunc(priority);
 }
 export function resolveRunListeners(options) {
-    const runtimeListeners = "runtimeListeners" in options ? options.runtimeListeners : undefined;
-    const frontendListeners = "frontendListeners" in options ? options.frontendListeners : undefined;
     const listeners = options.listeners;
-    if (!listeners && !runtimeListeners && !frontendListeners) {
+    if (!listeners) {
         return undefined;
     }
-    return {
-        ...(runtimeListeners ?? {}),
-        ...(frontendListeners ?? {}),
-        ...(listeners ?? {}),
-    };
+    return listeners;
 }
 export function mergeRunResultOutput(result, streamedOutput) {
     return {

package/dist/runtime/harness/run/recovery.d.ts

@@ -0,0 +1,42 @@
+import type { MessageContent, RunResult, ThreadSummary, WorkspaceBundle } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+import type { AgentRuntimeAdapter } from "../../agent-runtime-adapter.js";
+import type { ConcurrencyConfig, RecoveryConfig } from "../../../workspace/support/workspace-ref-utils.js";
+type RecoveryBinding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
+type StartupRecoveryContext = {
+    persistence: RuntimePersistence;
+    workspace: WorkspaceBundle;
+    runtimeAdapter: AgentRuntimeAdapter;
+    recoveryConfig: RecoveryConfig;
+    concurrencyConfig: ConcurrencyConfig;
+    getBinding: (agentId: string) => RecoveryBinding | undefined;
+    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
+    executeQueuedRun: (binding: RecoveryBinding, input: MessageContent, threadId: string, runId: string, agentId: string, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+        previousState?: RunResult["state"];
+        stateSequence?: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+        previousState: string | null;
+        checkpointRef?: string | null;
+        error?: string;
+    }) => Promise<unknown>;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    loadRunInput: (threadId: string, runId: string) => Promise<MessageContent>;
+    finalizeContinuedRun: (binding: RecoveryBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
+        previousState: RunResult["state"] | null;
+        stateSequence: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+    supportsRunningReplay: (binding: RecoveryBinding) => boolean;
+    isStaleRunningRun: (thread: ThreadSummary, nowMs?: number) => Promise<boolean>;
+    recordLlmSuccess: (startedAt: number) => void;
+    recordLlmFailure: (startedAt: number) => void;
+};
+export declare function recoverQueuedStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export declare function recoverRunningStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export declare function recoverResumingStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export {};

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/run/routing.d.ts

@@ -1,7 +1,5 @@
-import { type MessageContent, type ThreadSummary, type TranscriptMessage, type WorkspaceBundle } from "../../../contracts/types.js";
-export declare function heuristicHostRoute(workspace: WorkspaceBundle, input: MessageContent): string;
+import { type MessageContent, type ThreadSummary, type WorkspaceBundle } from "../../../contracts/types.js";
 export declare function getDefaultHostAgentId(workspace: WorkspaceBundle, preferredHostAgentId: string): string;
-export declare function buildRoutingInput(input: MessageContent, history?: TranscriptMessage[]): string;
 export declare function resolveSelectedAgentId(options: {
     workspace: WorkspaceBundle;
     input: MessageContent;

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

@@ -1,35 +1,12 @@
 import { AUTO_AGENT_ID } from "../../../contracts/types.js";
-import { extractMessageText } from "../../../utils/message-content.js";
-import { heuristicRoute, inferRoutingBindings } from "../../support/harness-support.js";
+import { inferRoutingBindings } from "../../support/harness-support.js";
 import { isRuntimeEntryBinding } from "../../support/runtime-entry.js";
-export function heuristicHostRoute(workspace, input) {
-    const { primaryBinding, secondaryBinding } = inferRoutingBindings(workspace);
-    return heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
-}
 export function getDefaultHostAgentId(workspace, preferredHostAgentId) {
     const preferredBinding = workspace.bindings.get(preferredHostAgentId);
     if (preferredBinding && isRuntimeEntryBinding(preferredBinding)) {
         return preferredBinding.agent.id;
     }
-    return heuristicHostRoute(workspace, "");
-}
-export function buildRoutingInput(input, history = []) {
-    const inputText = extractMessageText(input);
-    const priorHistory = history.filter((message) => extractMessageText(message.content).trim());
-    if (priorHistory.length === 0) {
-        return inputText;
-    }
-    const recentTurns = priorHistory.slice(-6).map((message) => {
-        const role = message.role === "assistant" ? "assistant" : "user";
-        const compact = extractMessageText(message.content).replace(/\s+/g, " ").trim();
-        return `${role}: ${compact.slice(0, 240)}`;
-    });
-    return [
-        "Recent conversation context:",
-        ...recentTurns,
-        "",
-        `Current user request: ${inputText}`,
-    ].join("\n");
+    return inferRoutingBindings(workspace).primaryBinding?.agent.id ?? "agent";
 }
 export async function resolveSelectedAgentId(options) {
     const { workspace, input, requestedAgentId, threadId, preferredHostAgentId, getThreadSummary } = options;

package/dist/runtime/harness/run/run-lifecycle.d.ts

@@ -13,22 +13,11 @@ type LifecycleRuntime<TBinding> = {
         approval: InternalApprovalRecord;
         event: HarnessEvent;
     }>;
-    synthesizeFinalResult: (binding: TBinding, input: MessageContent, actual: RunResult) => Promise<{
-        output: string;
-        finalMessageText?: string;
-        modelId: string;
-    } | null | undefined>;
-    reviewRunResult: (binding: TBinding, input: MessageContent, actual: RunResult) => Promise<{
-        modelId: string;
-        assessment: string;
-    } | null | undefined>;
 };
 export declare function appendAssistantMessage(persistence: Pick<RuntimePersistence, "appendThreadMessage">, threadId: string, runId: string, content?: string): Promise<void>;
 export declare function checkpointRefForState(threadId: string, runId: string, state: RunResult["state"]): string | null;
 export declare function expirePendingApprovals(runtime: Pick<LifecycleRuntime<never>, "persistence" | "emit">, threadId: string, runId: string): Promise<void>;
 export declare function finalizeCancelledRun(runtime: Pick<LifecycleRuntime<never>, "persistence" | "emit" | "setRunStateAndEmit">, threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string): Promise<RunResult>;
-export declare function synthesizeCompletedRun<TBinding>(runtime: Pick<LifecycleRuntime<TBinding>, "synthesizeFinalResult">, binding: TBinding, input: MessageContent, actual: RunResult): Promise<RunResult>;
-export declare function reviewCompletedRun<TBinding>(runtime: Pick<LifecycleRuntime<TBinding>, "reviewRunResult" | "emit">, binding: TBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult): Promise<void>;
 export declare function finalizeContinuedRun<TBinding>(runtime: LifecycleRuntime<TBinding>, binding: TBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
     previousState: RunResult["state"] | null;
     stateSequence: number;

package/dist/runtime/harness/run/run-lifecycle.js

@@ -45,65 +45,22 @@ export async function finalizeCancelledRun(runtime, threadId, runId, previousSta
         output: reason ? `cancelled: ${reason}` : "cancelled",
     };
 }
-export async function synthesizeCompletedRun(runtime, binding, input, actual) {
-    try {
-        const synthesized = await runtime.synthesizeFinalResult(binding, input, actual);
-        if (!synthesized) {
-            return actual;
-        }
-        return {
-            ...actual,
-            output: synthesized.output,
-            finalMessageText: synthesized.finalMessageText,
-            metadata: {
-                ...(typeof actual.metadata === "object" && actual.metadata ? actual.metadata : {}),
-                finalSynthesis: {
-                    modelId: synthesized.modelId,
-                },
-            },
-        };
-    }
-    catch {
-        return actual;
-    }
-}
-export async function reviewCompletedRun(runtime, binding, threadId, runId, input, actual) {
-    try {
-        const review = await runtime.reviewRunResult(binding, input, actual);
-        if (!review) {
-            return;
-        }
-        await runtime.emit(threadId, runId, 7, "run.reviewed", {
-            modelId: review.modelId,
-            assessment: review.assessment,
-        });
-    }
-    catch {
-        // Review is advisory; do not fail the completed run if the review pass fails.
-    }
-}
 export async function finalizeContinuedRun(runtime, binding, threadId, runId, input, actual, options) {
     let approval;
-    const finalizedActual = actual.state === "completed"
-        ? await synthesizeCompletedRun(runtime, binding, input, actual)
-        : actual;
-    await appendAssistantMessage(runtime.persistence, threadId, runId, finalizedActual.output);
+    await appendAssistantMessage(runtime.persistence, threadId, runId, actual.output);
     const checkpointRef = checkpointRefForState(threadId, runId, actual.state);
-    await runtime.setRunStateAndEmit(threadId, runId, options.stateSequence, finalizedActual.state, {
+    await runtime.setRunStateAndEmit(threadId, runId, options.stateSequence, actual.state, {
         previousState: options.previousState,
         checkpointRef,
     });
-    if (finalizedActual.state === "waiting_for_approval" && options.approvalSequence) {
-        approval = (await runtime.requestApprovalAndEmit(threadId, runId, input, finalizedActual.interruptContent, checkpointRef, options.approvalSequence)).approval;
-    }
-    if (finalizedActual.state === "completed") {
-        await reviewCompletedRun(runtime, binding, threadId, runId, input, finalizedActual);
+    if (actual.state === "waiting_for_approval" && options.approvalSequence) {
+        approval = (await runtime.requestApprovalAndEmit(threadId, runId, input, actual.interruptContent, checkpointRef, options.approvalSequence)).approval;
     }
     return {
-        ...finalizedActual,
+        ...actual,
         threadId,
         runId,
-        approvalId: approval?.approvalId ?? finalizedActual.approvalId,
-        pendingActionId: approval?.pendingActionId ?? finalizedActual.pendingActionId,
+        approvalId: approval?.approvalId ?? actual.approvalId,
+        pendingActionId: approval?.pendingActionId ?? actual.pendingActionId,
     };
 }

package/dist/runtime/harness/runtime-defaults.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeHealthSnapshot, WorkspaceBundle } from "../../contracts/types.js";
+export declare function isThreadMemorySyncEnabled(workspace: WorkspaceBundle): boolean;
+export declare function isInventoryEnabled(workspace: WorkspaceBundle): boolean;
+export declare function createDefaultHealthSnapshot(activeRunSlots: number, pendingRunSlots: number): RuntimeHealthSnapshot;

package/dist/runtime/harness/runtime-defaults.js

@@ -0,0 +1,39 @@
+export function isThreadMemorySyncEnabled(workspace) {
+    const runtimeMemory = workspace.bindings.values().next().value?.harnessRuntime.runtimeMemory;
+    const syncConfig = typeof runtimeMemory?.threadMemorySync === "object" && runtimeMemory.threadMemorySync
+        ? runtimeMemory.threadMemorySync
+        : undefined;
+    return runtimeMemory?.enabled === true && syncConfig?.enabled === true;
+}
+export function isInventoryEnabled(workspace) {
+    const runtime = workspace.refs.get("runtime/default");
+    const value = runtime && "value" in runtime && typeof runtime.value === "object" && runtime.value
+        ? runtime.value
+        : undefined;
+    const inventory = typeof value?.inventory === "object" && value.inventory
+        ? value.inventory
+        : undefined;
+    return inventory?.enabled === true;
+}
+export function createDefaultHealthSnapshot(activeRunSlots, pendingRunSlots) {
+    const updatedAt = new Date().toISOString();
+    const healthy = { status: "healthy", updatedAt, reason: "health monitor disabled" };
+    return {
+        status: "healthy",
+        updatedAt,
+        checks: {
+            runtime: healthy,
+            llm: healthy,
+            persistence: healthy,
+            capacity: healthy,
+            workload: healthy,
+        },
+        symptoms: [],
+        stats: {
+            activeRunSlots,
+            pendingRunSlots,
+            pendingApprovals: 0,
+            stuckRuns: 0,
+        },
+    };
+}

package/dist/runtime/harness/system/inventory.js

@@ -41,6 +41,7 @@ function mergeRequirementOptions(binding, options = {}) {
     return {
         ...fromBackend,
         ...options,
+        assessRequirements: options.assessRequirements ?? true,
         env: options.env ? { ...(fromBackend.env ?? {}), ...options.env } : fromBackend.env,
         path: options.path ?? fromBackend.path,
     };
@@ -58,7 +59,7 @@ function toSkillRecords(skillPaths, options = {}) {
             allowedTools: metadata.allowedTools,
             userInvocable: metadata.userInvocable,
             openclaw: metadata.openclaw,
-            requirements: assessSkillRequirements(metadata, options),
+            ...(options.assessRequirements === false ? {} : { requirements: assessSkillRequirements(metadata, options) }),
         };
     });
 }

package/dist/runtime/harness/system/skill-requirements.d.ts

@@ -18,6 +18,7 @@ export type SkillRequirementAssessment = {
     openclaw?: OpenClawRequirementAssessment;
 };
 export type RequirementAssessmentOptions = {
+    assessRequirements?: boolean;
     env?: Record<string, string | undefined>;
     path?: string;
     availableBins?: string[];

package/dist/runtime/harness.d.ts

@@ -17,10 +17,8 @@ export declare class AgentHarnessRuntime {
     private readonly vectorStores;
     private readonly defaultStore;
     private readonly runtimeMemoryStore;
-    private readonly routingSystemPrompt?;
     private readonly routingRules;
     private readonly routingDefaultAgentId?;
-    private readonly modelRoutingEnabled;
     private readonly threadMemorySync;
     private readonly unregisterThreadMemorySync;
     private readonly resolvedRuntimeAdapterOptions;
@@ -37,20 +35,15 @@ export declare class AgentHarnessRuntime {
     private runtimeEventSequence;
     private listHostBindings;
     private defaultRunRoot;
-    private heuristicRoute;
     private getDefaultHostAgentId;
-    private buildRoutingInput;
     private resolveSelectedAgentId;
-    private resolveStore;
-    private resolveStoreFromConfig;
-    private resolveEmbeddingModel;
-    private resolveVectorStore;
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
+    private createHealthMonitor;
+    private recordLlmSuccess;
+    private recordLlmFailure;
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
     getHealth(): Promise<RuntimeHealthSnapshot>;
-    private getBinding;
-    private listAgentTools;
     private resolveAgentTools;
     private supportsRunningReplay;
     listThreads(filter?: {
@@ -87,36 +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 synthesizeCompletedRun;
-    private reviewCompletedRun;
-    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>;
     }>;
@@ -127,4 +109,3 @@ export declare class AgentHarnessRuntime {
     private reclaimExpiredClaimedRuns;
     private isStaleRunningRun;
 }
-export { AgentHarnessRuntime as AgentHarness };